====== FPC Solution Manager ======

Projektmanagement, Build-System, Debugging und Form Designer für Free Pascal / Lazarus in Visual Studio Code.

**Package-ID:** ''wvds.wvds-fpc-solution-manager''

===== Übersicht =====

Der Solution Manager ist die zentrale Extension für die Free-Pascal-Entwicklung in VSCode. Er bietet:

  * **Tree View** — Hierarchische Darstellung von Projektgruppen, Projekten, Units und Formularen
  * **Build-System** — Build, Rebuild, Clean über ''lazbuild'' oder FPC Direct
  * **Form Designer** — Visueller LFM-Editor mit Skin-Unterstützung
  * **Debugger** — Integriertes Debugging mit ''fpdserver'' / GDB
  * **Language Server** — Code Completion, Go to Definition, Hover via ''pasls''
  * **Code Formatter** — ''ptop'' oder ''jcf'' Integration

===== Projekt-Erkennung =====

Die Extension erkennt automatisch Projekte im geöffneten Workspace:

| Datei | Projekttyp |
^ ''.lpi'' | Lazarus-Projekt (Konsole, GUI, Library) |
^ ''.lpg'' | Projektgruppe (mehrere Projekte) |
^ ''.lpk'' | Lazarus-Package |
^ ''package.json'' | VSCode Extension (pas2js, virtuelles Projekt) |
^ ''.iss'' | InnoSetup Installer-Skript |

Multi-Root Workspaces werden unterstützt — jeder Workspace-Ordner wird separat gescannt.

===== Tree View =====

Der Tree View erscheint in der Activity Bar (linke Seite) mit dem FPC Solution Manager Icon.

==== Hierarchie ====

<code>
Workspace Folder
├── Projektgruppe (.lpg)
│   ├── Projekt (.lpi)      ← mit Inline Build/Run Buttons
│   │   ├── Units (.pas)
│   │   ├── Formulare (.pas + .lfm)
│   │   ├── Build Modi (Debug, Release, ...)
│   │   ├── Dependencies (Required Packages)
│   │   └── Resources (.rc)
│   └── Projekt 2 ...
├── Package (.lpk)
│   ├── Units
│   └── Required Packages
├── Extension (package.json) ← Virtuelles pas2js-Projekt
│   ├── Units
│   └── npm Dependencies
└── Setup (.iss)             ← InnoSetup Projekt
    └── Sections ([Files], [Run], ...)
</code>

==== Kontextmenü ====

Rechtsklick auf Tree-Elemente zeigt kontextabhängige Aktionen:

**Projekt:**
  * Build / Rebuild / Clean
  * Build and Run / Run / Stop
  * Properties (F4)
  * Select Build Mode
  * Add Unit / Form / Existing File
  * Navigate (Dependencies, Call Hierarchy)

**Projektgruppe:**
  * Build All / Rebuild All / Clean All
  * Set Active Project
  * Add New/Existing Project

**Unit / Form:**
  * Open File (Enter)
  * Reveal in File Explorer
  * Copy Path / Copy Relative Path
  * Remove from Project
  * Show Dependencies / Call Hierarchy

==== Editor-Kontextmenü ====

Rechtsklick im Pascal-Editor (''.pas'', ''.pp'', ''.lpr'') zeigt das **FPC Solution Manager** Submenü:

  * Sort and Remove Unused Units
  * Show Call Hierarchy
  * Show Dependency Explorer
  * Add Watch (nur bei Selektion)

==== Title-Bar Buttons ====

| Button | Aktion |
^ Filter | Baumansicht filtern |
^ New Project | Neues Projekt erstellen |
^ Refresh | Baum neu laden |
^ Open Group | Projektgruppe öffnen |
^ Settings | Extension-Einstellungen |

===== Build-System =====

==== Build-Modi ====

Jedes Projekt kann mehrere Build-Modi haben:

| Modus | Beschreibung |
^ Debug | Debug-Informationen, keine Optimierung |
^ Release | Optimiert, keine Debug-Infos |
^ Custom | Benutzerdefinierte Compiler-Optionen |

Build-Modus wechseln: Rechtsklick auf Projekt → **Select Build Mode** oder ''Ctrl+Shift+M''.

==== Build-Kommandos ====

| Kommando | Beschreibung | Tastenkürzel |
^ Build Project | Inkrementeller Build | ''Ctrl+Shift+B'' |
^ Rebuild Project | Vollständiger Neubau | ''Shift+F9'' |
^ Clean Project | Build-Artefakte löschen | ''Ctrl+Shift+C'' |
^ Build and Run | Bauen und starten | ''F9'' |
^ Compile (Syntax Check) | Nur Syntax prüfen, nicht linken | — |
^ Build All | Alle Projekte in der Gruppe bauen | — |
^ Build in Dependency Order | Projekte nach Abhängigkeiten sortiert bauen | — |

==== Build-Backends ====

| Backend | Verwendung |
^ ''lazbuild'' | Standard — nutzt Lazarus Build-System mit LCL-Unterstützung |
^ FPC Direct | Fallback — ruft ''fpc'' direkt auf (wenn kein ''lazbuild'' konfiguriert) |

==== Pre/Post-Build Kommandos ====

In den Settings können Shell-Kommandos definiert werden, die vor/nach jedem Build laufen:

<code>
fpc-solution-manager.preBuildCommand: "echo Building {projectName} in {buildMode}"
fpc-solution-manager.postBuildCommand: "copy {outputPath} D:\\Deploy\\"
</code>

Verfügbare Variablen: ''{projectName}'', ''{buildMode}'', ''{projectDir}'', ''{outputPath}''

==== Problem Matcher ====

Compiler-Fehler werden automatisch als VSCode Diagnostics angezeigt. Klick auf einen Fehler springt zur entsprechenden Zeile.

Format: ''Datei(Zeile,Spalte) Severity: Nachricht''

===== Projekte ausführen =====

| Kommando | Tastenkürzel | Beschreibung |
^ Run Project | ''F5'' | Kompiliertes Programm starten |
^ Build and Run | ''F9'' | Bauen und sofort starten |
^ Stop Process | ''Shift+F5'' / ''Ctrl+F2'' | Laufenden Prozess beenden |

==== Ausführungsmodus ====

  * **Output Panel** (Standard): Ausgabe im VSCode Output-Kanal
  * **Terminal**: Für interaktive CLI-Programme mit stdin — aktivieren über ''fpc-solution-manager.runInTerminal''

==== Run Configuration ====

Über **Select Run Configuration** können Kommandozeilen-Argumente und Arbeitsverzeichnis konfiguriert werden.

===== Debugging =====

==== Voraussetzungen ====

Der Debugger benötigt ''fpdserver'' (Free Pascal Debug Server) als Backend.

**fpdserver beschaffen:**

  * **Lazarus-Bundle (ab 3.0):** ''fpdserver'' ist bereits enthalten (''<lazarus>/tools/fpdserver'')
  * **Manuell bauen:** Aus dem FPC-Quellcode:

<code bash>
cd <fpc-source>/packages/fcl-passrc/utils/fpdserver
lazbuild --bm=Release fpdserver.lpi
</code>

**Konfiguration:**

  * ''fpc-solution-manager.fpdserverPath'' — Pfad zu ''fpdserver.exe'' (leer = Auto-Erkennung)

<note>Ohne ''fpdserver'' funktioniert die Debugging-Integration nicht. Die Extension sucht automatisch im Lazarus-Installationsverzeichnis.</note>

==== launch.json ====

Erstelle eine ''launch.json'' im ''.vscode''-Ordner des Workspace:

<code javascript>
{
  "type": "lazarus",
  "request": "launch",
  "name": "Debug MyApp",
  "program": "${command:fpcse2.getExecutablePath}",
  "cwd": "${workspaceFolder}",
  "stopOnEntry": false,
  "args": []
}
</code>

**Tipp:** ''${command:fpcse2.getExecutablePath}'' ermittelt automatisch den Output-Pfad aus den Projekteinstellungen.

==== Konfigurationsattribute ====

| Attribut | Typ | Beschreibung | Standard |
^ ''program'' | String | Pfad zum kompilierten Programm (erforderlich) | — |
^ ''cwd'' | String | Arbeitsverzeichnis | ''${workspaceFolder}'' |
^ ''args'' | Array | Kommandozeilen-Argumente | ''[]'' |
^ ''stopOnEntry'' | Boolean | Bei Programmstart anhalten | ''false'' |

==== Features ====

  * **Breakpoints** in ''.pas'' und ''.inc'' Dateien
  * **Step In/Out/Over** — Schrittweise Ausführung
  * **Variables** — Lokale und globale Variablen inspizieren
  * **Watches** — Ausdrücke überwachen (''Ctrl+Alt+W'' bei Selektion)
  * **Call Stack** — Aufrufkette anzeigen
  * **Immediate Window** — Ausdrücke zur Laufzeit auswerten

==== Breakpoints ====

  * **Zeilen-Breakpoints** — Klick auf den Zeilenrand in ''.pas'' und ''.inc'' Dateien
  * **Bedingte Breakpoints** — Rechtsklick auf Breakpoint → ''Edit Breakpoint'' → Bedingung eingeben (z.B. ''i > 100'')
  * **Hit Count** — Breakpoint nur nach N Treffern auslösen
  * **Logpoints** — Nachricht in die Konsole ausgeben ohne Programmfluss zu unterbrechen

==== Watches ====

Ausdrücke zur Laufzeit überwachen:

  * **Hinzufügen:** ''Ctrl+Alt+W'' bei selektiertem Text im Pascal-Editor
  * **Panel:** Im unteren Bereich unter **FPC Solution Manager → Watches**
  * **Ausdrücke:** Variablen, Record-Felder (''MyRecord.Field''), Array-Indizes (''MyArray[0]'')

==== Immediate Window ====

Interaktive Auswertung während einer Debug-Sitzung:

  * **Öffnen:** Panel **FPC Solution Manager → Immediate**
  * Ausdruck eingeben und ''Enter'' drücken
  * Unterstützt: Variablenwerte, Typ-Casts, einfache arithmetische Ausdrücke

==== Debug-Panels ====

Im unteren Panel (FPC-Bereich):

  * **Immediate** — Interaktive Auswertung von Ausdrücken
  * **Watches** — Überwachte Variablen/Ausdrücke

==== Build-Modus für Debugging ====

Für erfolgreiches Debugging muss das Projekt im **Debug**-Modus gebaut werden:

  * Build-Modus wechseln: ''Ctrl+Shift+M'' → **Debug**
  * Debug-Informationen: Compiler-Flags ''-g -gl -gw'' müssen aktiv sein
  * Optimierung deaktivieren: Keine ''-O2'' im Debug-Modus

==== Fehlerbehebung ====

| Problem | Lösung |
^ fpdserver nicht gefunden | ''fpc-solution-manager.fpdserverPath'' setzen oder ''fpdserver'' bauen (siehe oben) |
^ Breakpoints werden nicht getroffen | Projekt im **Debug**-Modus bauen (''Ctrl+Shift+M'' → Debug) |
^ Variablen nicht sichtbar | Debug-Infos prüfen: ''-g -gl -gw'' müssen im Build-Modus gesetzt sein |
^ Stepping springt unerwartet | Optimierung deaktivieren: ''-O2'' nur im Release-Modus verwenden |

===== Form Designer =====

Der Form Designer öffnet sich automatisch für ''.lfm'' Dateien.

==== Bedienung ====

| Aktion | Tastenkürzel |
^ Toggle Form/Code | ''F12'' |
^ View Form as Text | ''Alt+F12'' |
^ Select Designer Skin | Command Palette |

==== Grid & Snap ====

| Setting | Beschreibung | Standard |
^ ''designer.snapToGrid'' | Komponenten am Raster einrasten | ''true'' |
^ ''designer.gridSize'' | Rastergröße in Pixel | ''8'' |
^ ''designer.showGrid'' | Raster-Punkte anzeigen | ''true'' |

==== Skins ====

Der Designer unterstützt Skins für das visuelle Erscheinungsbild:

  * ''fpc-solution-manager.designer.skinName'' — Aktiver Skin (z.B. ''WvdS-Shell'')
  * ''fpc-solution-manager.designer.skinVariant'' — Variante (z.B. ''Amber'', ''Plum'')
  * ''fpc-solution-manager.designer.defaultSkinAutoDetect'' — Automatische Light/Dark-Erkennung basierend auf VSCode-Theme

==== Zoom ====

''fpc-solution-manager.designer.zoom'' — Canvas-Zoom 50% bis 400%.

==== Komponenten-Packages ====

Zusätzliche Packages mit eigenen Komponenten können registriert werden:

<code json>
"fpc-solution-manager.designer.componentPackages": [
  "D:\\MyComponents\\mywidgets.lpk"
]
</code>

==== Custom Form Base Classes ====

Eigene Formular-Basisklassen für **Add Form (Typed)**:

<code json>
"fpc-solution-manager.formBaseClasses": [{
  "className": "TWvdSRibbonForm",
  "description": "WvdS Ribbon GUI Form",
  "unitName": "WvdS.Forms.Ribbon",
  "category": "WvdS",
  "hasOwnLfm": true,
  "defaultWidth": 1024,
  "defaultHeight": 768
}]
</code>

===== Custom Editors =====

| Editor | Dateityp | Beschreibung |
^ Form Designer | ''.lfm'' | Visueller Lazarus-Formular-Editor |
^ PO Translation Editor | ''.po'' | Übersetzungs-Editor für Lokalisierung |
^ Resource Editor | ''.rc'' | Ressourcen-Editor (Icons, Bitmaps, Strings) |

==== PO Translation Editor ====

Öffnet sich für ''.po'' Dateien (GNU gettext). Bietet:

  * Tabellarische Ansicht aller Übersetzungseinträge (Original → Übersetzung)
  * Suche und Filterung nach Schlüssel oder Text
  * Direkte Bearbeitung der Übersetzungen im WebView-Panel
  * Änderungen werden in die ''.po'' Datei zurückgeschrieben

==== Resource Editor ====

Öffnet sich für ''.rc'' Dateien. Bietet:

  * Übersicht aller Ressourcen (Icons, Bitmaps, Cursors, String Tables, Version Info)
  * Hinzufügen und Entfernen von Ressourcen-Einträgen
  * Pfade zu Ressourcen-Dateien bearbeiten

===== Language Server (pasls) =====

Optionale Integration des Pascal Language Servers für erweiterte Code-Funktionen.

==== Aktivierung ====

  * ''fpc-solution-manager.pasls.enabled'' — ''true'' (Standard)
  * ''fpc-solution-manager.paslsPath'' — Pfad zu ''pasls.exe'' (leer = Auto-Erkennung)
  * ''fpc-solution-manager.lazarusSourcePath'' — Lazarus-Quellen für Symbol-Auflösung

==== Features ====

| Feature | Tastenkürzel | Beschreibung |
^ Code Completion | ''Ctrl+Space'' | Vervollständigung von Identifiern, Methoden, Units |
^ Signature Help | automatisch | Parameterliste beim Tippen von ''('' |
^ Go to Definition | ''F12'' | Springt zur Definition/Implementation eines Symbols |
^ Go to Declaration | ''Ctrl+Click'' auf Interface | Springt zur Interface-Deklaration (statt Implementation) |
^ Go to Implementation | ''Ctrl+Shift+F12'' | Springt zur Implementation (delegiert intern an Definition) |
^ Document Symbols | ''Ctrl+Shift+O'' | Symbolliste der aktuellen Datei — Methoden und Prozeduren (Outline) |
^ Workspace Symbols | ''Ctrl+T'' | Symbolsuche über alle Dateien im Workspace |
^ Find All References | ''Shift+F12'' | Alle Verwendungen eines Symbols im Workspace |
^ Document Highlight | automatisch | Hervorhebung aller Vorkommen eines Identifiers in der aktuellen Datei |
^ Hover mit Typ-Info | Mauszeiger | Signatur + PasDoc-Dokumentation + Quellposition (siehe unten) |

==== Hover mit Typ-Info und PasDoc ====

Beim Überfahren eines Symbols mit der Maus zeigt der Hover-Tooltip bis zu drei Informationsebenen:

  - **Signatur** — Die vollständige Deklaration als syntax-gehighlighteter Pascal Code-Block, extrahiert von CodeTools ''FindSmartHint'' (z.B. ''private procedure TMyClass.DoSomething(const A: Integer): Boolean'') — inklusive Sichtbarkeit, Klassenname, Parameter-Modifier und Rückgabetyp
  - **PasDoc-Dokumentation** — Kommentare im Format ''(** @abstract(...) @param(...) @returns(...) *)'' direkt aus dem Quellcode, als formatiertes Markdown
  - **Quellposition** — Dateiname und Zeilenposition der Deklaration (z.B. ''MyUnit.pas(42,5)'')

pasls stellt ''textDocument/hover'' bereit und nutzt intern CodeTools ''FindSmartHint'' (dieselbe Engine wie Lazarus IDE) für die Signatur-Extraktion. PasDoc-Kommentare werden über ''GetPasDocComments'' ausgelesen und serverseitig in Markdown formatiert. Falls pasls nicht verfügbar ist, verwendet die Extension ''textDocument/definition'' als Fallback mit client-seitiger Mehrzeilen-Extraktion.

**Beispiel-Hover:**

<code>
┌───────────────────────────────────────────────────────────┐
│ private procedure TMyClass.DoSomething(const A: Integer); │  ← Signatur (FindSmartHint)
│ ───────────────────────────────────────────────────────── │
│ Führt die Aktion aus.                                     │  ← @abstract
│                                                           │
│ Parameters:                                               │
│ - A — Der Wert                                            │  ← @param
│ ───────────────────────────────────────────────────────── │
│ Source: MyUnit.pas(42,5)                                  │  ← Quellposition
└───────────────────────────────────────────────────────────┘
</code>

**Unterstützte PasDoc-Tags:**

| Tag | Beschreibung | Beispiel |
^ ''@abstract'' | Kurzbeschreibung | ''@abstract(Berechnet die Checksumme)'' |
^ ''@param'' | Parameter-Dokumentation | ''@param(Buffer Die zu prüfenden Daten)'' |
^ ''@returns'' | Rückgabewert | ''@returns(CRC32-Wert als Cardinal)'' |
^ ''@raises'' | Ausnahmen | ''@raises(EInvalidOperation Bei leerem Buffer)'' |

<note>PasDoc-Kommentare beginnen mit ''(**'' (doppelter Stern). Normale ''(*'' Kommentare werden nicht als Dokumentation angezeigt.</note>

==== Geplante Features ====

Die folgenden Features erfordern serverseitige Unterstützung durch pasls und sind aktuell noch **nicht verfügbar**:

  * **Rename Symbol** (''F2'') — Umbenennung eines Symbols über alle Dateien. Erfordert ''textDocument/rename'' in pasls.
  * **Live Diagnostics** — Fehler und Warnungen beim Tippen. Erfordert tiefere CodeTools-Integration in pasls.

<note>Die Extension registriert bereits einen Provider für Rename. Sobald pasls ''textDocument/rename'' unterstützt, funktioniert das Feature automatisch.</note>

==== Workspace Symbols ====

''Ctrl+T'' öffnet den Workspace Symbol Picker. Hier können Prozeduren, Funktionen, Typen und Variablen über alle Dateien im Workspace gesucht werden.

  * Tippe einen Suchbegriff ein → pasls liefert passende Symbole
  * ''Enter'' navigiert direkt zur Definitionsstelle
  * Leere Suche → leere Liste (kein Absturz)

===== Code Formatter =====

| Setting | Beschreibung | Standard |
^ ''formatter.engine'' | ''ptop'', ''jcf'', oder ''none'' | ''ptop'' |
^ ''formatter.ptopPath'' | Pfad zu ''ptop'' | Auto-Erkennung |
^ ''formatter.jcfPath'' | Pfad zu ''jcf'' | Auto-Erkennung |
^ ''formatter.configPath'' | Konfigurationsdatei (''.ptop.cfg'' / ''.jcf'') | — |
^ ''formatter.formatOnSave'' | Automatisch bei Speichern formatieren | ''false'' |

===== Cross-Compilation (WSL) =====

Linux-Builds auf Windows über WSL (Windows Subsystem for Linux).

==== Voraussetzungen ====

  - **WSL installieren:** ''wsl --install'' in PowerShell (Administrator)
  - **Distribution wählen:** z.B. ''Ubuntu'' (Standard) oder ''Debian''
  - **FPC in WSL installieren:**

<code bash>
# In WSL:
sudo apt install fpc lazarus
</code>

==== Aktivierung ====

  * ''fpc-solution-manager.wslEnabled'' — ''true''
  * ''fpc-solution-manager.wslActiveDistro'' — WSL-Distribution (z.B. ''Ubuntu'')
  * ''fpc-solution-manager.wslLazbuildPath'' — Linux-Pfad zu ''lazbuild'' (z.B. ''/usr/bin/lazbuild'')
  * ''fpc-solution-manager.wslFpcPath'' — Linux-Pfad zu ''fpc''

==== Kommandos ====

  * **Select Cross-Compile Target** — Zielplattform wählen (x86_64-linux, i386-linux, aarch64-linux)
  * **Configure WSL** — WSL-Einstellungen öffnen
  * **Build for Linux (WSL)** — Linux-Build starten

==== Ablauf ====

  - Zielplattform wählen: Rechtsklick auf Projekt → **Select Cross-Compile Target**
  - Build starten: **Build for Linux (WSL)** oder ''Ctrl+Shift+B'' (wenn WSL-Target aktiv)
  - Die Extension übergibt den Build an ''lazbuild'' / ''fpc'' innerhalb der WSL-Instanz
  - Output-Dateien landen im konfigurierten Ausgabepfad

===== Projekt-Wizard =====

Der **Unified Project Wizard** führt in fünf Schritten vom leeren Workspace zum fertigen Projekt:

  - **Intent wählen:** Neues FPC-Projekt, neues pas2js-Projekt oder bestehendes öffnen
  - **Toolchain-Check:** Prüft FPC/Lazarus/pas2js Verfügbarkeit (wird übersprungen wenn alles OK)
  - **Projekttyp wählen:** Filterbarer Karten-Katalog mit 10 Projekttypen
  - **Konfigurieren:** Name, Speicherort und typspezifische Optionen
  - **Zusammenfassung:** Vorschau der generierten Dateien, dann Finish

==== Aufruf ====

  * **Automatisch:** Beim Öffnen eines leeren Workspace (deaktivierbar über ''autoShowStartWizard'')
  * **Command Palette:** ''Ctrl+Shift+P'' → ''FPC: New Project...''
  * **Welcome View:** Klick auf "New Project Wizard..." im Solution Manager Panel

==== Projekttypen ====

^ Typ ^ Beschreibung ^
| Application | GUI-Anwendung mit LCL-Formularen |
| Console | Konsolen-Anwendung |
| Library | Shared Library (.dll / .so) |
| Package | Wiederverwendbares Lazarus-Package (.lpk) |
| pas2js Web App | Browser-basierte Anwendung mit pas2js |

==== Quick-Shortcut ====

Über ''Ctrl+Shift+P'' → ''New Project...'' steht weiterhin der klassische Projekt-Wizard als Schnellzugriff bereit.

==== Template-Defaults ====

Template-Defaults können in den Settings definiert werden:

  * ''templates.companyName'' — Firmenname
  * ''templates.author'' — Autor
  * ''templates.copyright'' — Copyright-Hinweis

===== Projekt-Eigenschaften =====

Über **Properties** (''F4'') oder Rechtsklick → Properties:

==== General ====

Projektname, Projekttyp, Ausgabepfad, Icon, Version.

==== Paths ====

  * Unit Search Paths (''OtherUnitFiles'')
  * Include Paths
  * Library Paths

==== Compiler Options ====

Build-Modi mit ihren jeweiligen Compiler-Optionen.

==== Dependencies ====

Required Packages (z.B. LCL, SynEdit, ...).

===== Uses Organizer =====

**Sort and Remove Unused Units** (Rechtsklick im Pascal-Editor):

  * Entfernt nicht verwendete Units aus ''uses''
  * Sortiert ''interface'' und ''implementation'' uses alphabetisch

===== Dependency Explorer =====

**Show Dependencies** — verfügbar im Tree View und im Editor-Kontextmenü:

  * Zeigt Unit-Abhängigkeiten als Baum
  * Erkennt zirkuläre Referenzen
  * Hilft beim Refactoring

| Aufruf | Verhalten |
^ Rechtsklick auf Projekt im Tree | Zeigt Projekt-Abhängigkeiten (alle Units und Packages) |
^ Rechtsklick auf Package im Tree | Zeigt Package-Abhängigkeiten |
^ Rechtsklick auf Unit im Tree | Zeigt Unit-Abhängigkeiten (''uses''-Klauseln) |
^ Editor-Kontextmenü → Show Dependencies | Zeigt Abhängigkeiten der aktuell geöffneten Datei |

==== Call Hierarchy ====

**Show Call Hierarchy** — verfügbar im Tree View und im Editor-Kontextmenü:

=== Aus dem Tree View ===

Rechtsklick auf eine Unit → **Show Call Hierarchy** öffnet ein WebView-Panel mit:

  * **Incoming** — Welche Funktionen rufen dieses Symbol auf (Callers)
  * **Outgoing** — Welche Funktionen ruft dieses Symbol auf (Callees)
  * Klickbare Einträge navigieren direkt zur Aufrufstelle

=== Aus dem Editor (Peek-Ansicht) ===

Rechtsklick im Pascal-Editor → **FPC Solution Manager** → **Show Call Hierarchy** zeigt die Call Hierarchy als **Inline-Peek-Widget** direkt im Editor an (ähnlich wie ''Peek Definition''). Der Cursor muss auf einem Funktions- oder Methodennamen stehen.

<note>Die Call Hierarchy (Outgoing Calls) funktioniert über Extension-eigene Analyse. Incoming Calls (Callers) erfordern pasls-Unterstützung für ''textDocument/references'', die aktuell noch nicht verfügbar ist.</note>

===== Projekt-Verwaltung =====

==== Dateien hinzufügen ====

| Kommando | Beschreibung |
^ Add Unit | Neue Pascal-Unit erstellen und zum Projekt hinzufügen |
^ Add Form | Neues Formular (Unit + LFM) erstellen |
^ Add Form (Typed) | Formular mit benutzerdefinierter Basisklasse |
^ Add Existing File | Bestehende Datei zum Projekt hinzufügen |
^ Add Required Package | Lazarus-Package als Abhängigkeit hinzufügen |

==== Projektgruppen ====

| Kommando | Beschreibung |
^ New Project Group | Neue ''.lpg'' erstellen |
^ Add Project to Group | Bestehendes Projekt hinzufügen |
^ Remove from Group | Projekt aus Gruppe entfernen |
^ Set as Startup Project | Standard-Projekt für Run/Debug festlegen |

===== Tastenkürzel =====

| Kürzel | Aktion | Kontext |
^ ''Ctrl+Shift+B'' | Build Project | Tree View: Projekt |
^ ''F5'' | Run Project | Tree View: Projekt |
^ ''F9'' | Build and Run | Tree View: Projekt |
^ ''Shift+F9'' | Rebuild Project | Tree View: Projekt |
^ ''Ctrl+Shift+C'' | Clean Project | Tree View: Projekt |
^ ''F4'' | Properties | Tree View: Projekt/Package |
^ ''F12'' | Toggle Form/Code | Pascal-Editor / Form Designer |
^ ''Alt+F12'' | View Form as Text | Form Designer |
^ ''Ctrl+Shift+A'' | Add Unit | Tree View: Projekt/Ordner |
^ ''Ctrl+Shift+M'' | Select Build Mode | Tree View: Projekt |
^ ''Ctrl+Shift+R'' | Refresh Tree | Tree View fokussiert |
^ ''Ctrl+Shift+F'' | Filter Tree | Tree View fokussiert |
^ ''Shift+F5'' / ''Ctrl+F2'' | Stop Process | Tree View |
^ ''Alt+Shift+R'' | Reveal in Explorer | Tree View: Unit/Form |
^ ''Enter'' | Open File | Tree View: Unit/Form |
^ ''Ctrl+Alt+W'' | Add Watch | Pascal-Editor mit Selektion |

===== Einstellungen (Übersicht) =====

Alle Einstellungen beginnen mit ''fpc-solution-manager.'':

==== Tool Paths ====

^ Setting ^ Beschreibung ^
| ''lazbuildPath'' | Pfad zu ''lazbuild'' |
| ''fpcPath'' | Pfad zu ''fpc'' |
| ''lazarusPath'' | Lazarus-Installationsverzeichnis |
| ''lfmdPath'' | Pfad zu ''lfmd'' (Form Designer Backend) |
| ''fpcInstallations'' | Liste von FPC-Installationen (Multi-Version) |
| ''fpdserverPath'' | Pfad zu ''fpdserver'' (Debugger) |

==== Build ====

^ Setting ^ Standard ^ Beschreibung ^
| ''defaultBuildMode'' | ''Debug'' | Standard-Build-Modus |
| ''buildTimeoutSeconds'' | ''300'' | Build-Timeout in Sekunden |
| ''preBuildCommand'' | — | Shell-Kommando vor Build |
| ''postBuildCommand'' | — | Shell-Kommando nach Build |
| ''runInTerminal'' | ''false'' | Im Terminal statt Output ausführen |

==== Output & Logging ====

^ Setting ^ Standard ^ Beschreibung ^
| ''showCompilerOutput'' | ''true'' | Compiler-Ausgabe anzeigen |
| ''autoShowOutputOnBuild'' | ''true'' | Output-Panel bei Build öffnen |
| ''autoShowOutputOnError'' | ''false'' | Nur bei Fehler öffnen |
| ''logLevel'' | ''info'' | Log-Stufe (debug/info/warn/error) |

==== Workspace ====

^ Setting ^ Standard ^ Beschreibung ^
| ''autoDetectProjects'' | ''true'' | Automatische Projekt-Erkennung |
| ''watchProjectFiles'' | ''true'' | Datei-Änderungen überwachen |
| ''unitSearchPaths'' | ''[]'' | Zusätzliche Unit-Suchpfade |

===== Walkthrough =====

Beim ersten Start erscheint ein interaktiver Walkthrough:

  - **Configure Lazarus/lazbuild Path** — Toolchain einrichten
  - **Open a Project or Project Group** — Projekt öffnen
  - **Build Your First Project** — Erstes Projekt bauen
  - **Run Your Application** — Programm starten
  - **Create a New Project** — Neues Projekt erstellen

Erneut öffnen: ''Ctrl+Shift+P'' → ''Getting Started''.

===== Siehe auch =====

  * [[.:start|WvdS FPC Tools Übersicht]]
  * [[.:installation|Installation und Konfiguration]]
  * [[.:pas2js-studio|FPC PAS2JS Studio]]
  * [[.:iss-designer|FPC ISS Designer]]
  * [[.:faq|Häufige Fragen (FAQ)]]