sgcUI 2026.11: sgcChat, KI-Assistent und Team-Chat für Delphi, C++ Builder und .NET

· Versionen
sgcUI 2026.11: sgcChat, KI-Assistent und Team-Chat für Delphi und .NET
✦  Neue Version · sgcUI 2026.11

Lernen Sie sgcChat kennen.
Ein Chat in Ihrer Anwendung.

Ein KI-Assistent, der seine Antworten als formatiertes Markdown streamt, und ein Team-Chat mit Präsenz, Tippanzeige, Lesebestätigungen und Reaktionen. Native Steuerelemente für Delphi, C++ Builder und .NET.

Auch auf YouTube.

  • VCL
  • FireMonkey
  • WinForms
  • WPF
  • Avalonia
  • Headless SVG und PNG
Eine Unterhaltung mit einem KI-Assistenten und ein Team-Chat nebeneinander, gezeichnet von sgcChat
17sgcUI-Produkte
4Chat-Steuerelemente
5UI-Frameworks
12Sprachen

Heute veröffentlichen wir sgcUI 2026.11. Die Version bringt zwei neue Produkte: sgcChat, das einen KI-Assistenten-Chat und einen Team-Chat in Ihre eigene Anwendung bringt, und sgcSpreadsheet, eine Tabellenkalkulation im Excel-Stil. Außerdem schließt sie eine Reihe kleinerer Lücken in der Suite: Instrumente, die Benutzereingaben entgegennehmen, Datenbindung, die dem Dataset in beide Richtungen folgt, ein Dashboard als Webseite, Outlook-Serientermine im Planer, Skripte in Berichten und mehr.

sgcChat ist das sechzehnte sgcUI-Produkt. Es läuft auf VCL und FireMonkey für Delphi und C++ Builder sowie auf WinForms, WPF und Avalonia für .NET und ist in sgcUI Enterprise und All-Access enthalten. Es wird nicht als separates Paket verkauft.

sgcChat: ein KI-Assistent in Ihrer Anwendung

Eine KI-Antwort trifft in kleinen Teilen ein, und Benutzer erwarten, sie schon beim Entstehen zu lesen. TsgcChatAI bindet eine Unterhaltung an einen Provider, sendet den Verlauf und den System-Prompt und zeigt jedes Teilstück als formatiertes Markdown an, sobald es eintrifft. Der Provider läuft in einem Worker-Thread, sodass das Fenster reaktionsfähig bleibt, und das Chat-Panel bietet für jede Antwort Stopp, Neu generieren sowie Bearbeiten und erneut Senden.

Eine Unterhaltung mit einem KI-Assistenten im sgcChat-Panel
Der KI-Assistent im Chat-Panel.

sgcChat bindet Sie nicht an einen einzigen KI-Anbieter. TsgcChatAIProvider_AIChat verbindet sich mit TsgcAIChat von sgcWebSockets, das mit OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok und Mistral spricht. TsgcChatAIProvider_UICore nutzt die KI-Provider-Schicht, die alle sgcUI-Produkte gemeinsam verwenden, und mit TsgcChatAIEventProvider streamen Sie in einem Ereignis aus Ihrem eigenen Backend. So antwortet eine TsgcChatAI-Bindung mit OpenAI:

uses
  SysUtils, Classes,
  // sgcWebSockets
  sgcAI, sgcAI_Chat,
  // sgc
  sgcChat_AI, sgcChatWS_AI;

procedure UseOpenAI(aAI: TsgcChatAI; const aApiKey: string);
var
  oChat: TsgcAIChat;
  oProvider: TsgcChatAIProvider_AIChat;
begin
  oChat := TsgcAIChat.Create(aAI.Owner);
  oChat.Provider := aicpOpenAI;
  oChat.ChatOptions.ApiKey := aApiKey;
  oChat.ChatOptions.Model := 'gpt-4o-mini';

  oProvider := TsgcChatAIProvider_AIChat.Create(aAI.Owner);
  oProvider.Chat := oChat;

  aAI.Model := oChat.ChatOptions.Model;
  aAI.Provider := oProvider;
end;

Ändern Sie Provider, um Anthropic, Gemini, DeepSeek, Ollama, Grok oder Mistral zu verwenden. Die sgcChat-Hilfe enthält den vollständigen Schnellstart.

Die Kommunikation mit Claude, OpenAI, Gemini und den anderen LLM-Providern benötigt sgcWebSockets, das in All-Access enthalten ist. TsgcChatAIProvider_AIChat befindet sich im Bridge-Paket sgcChatWS (.NET: esegece.sgcChat.sgcWebSockets). Ohne sgcWebSockets kann dein eigener Code mit TsgcChatAIEventProvider jeden KI-Dienst aufrufen.

sgcChat: ein Team-Chat auf Ihrem eigenen Server

Support-Desks, Außendienstteams und interne Tools brauchen einen Chat, den ihre Benutzer bereits zu bedienen wissen. Die Chat-Ansicht gruppiert die Nachrichten jedes Autors mit Avatar und Namen, zeigt an, wer online, abwesend oder beschäftigt ist, zeigt, wer gerade tippt, und markiert jede Nachricht als gesendet, zugestellt oder gelesen. Benutzer antworten auf eine Nachricht, reagieren darauf, bearbeiten oder löschen ihre eigenen Nachrichten und senden Anhänge mit Bildvorschauen und Datei-Chips.

Ein Team-Chat mit Avataren, Präsenz und Lesebestätigungen in sgcChat
Ein Team-Chat mit Präsenz, Tippanzeige und Lesebestätigungen.

Der Chat hängt nicht von einem bestimmten Server ab. TsgcChatEventTransport übergibt jede Nachricht, jede Änderung der Tippanzeige, jede Bestätigung und jede Reaktion als dokumentierten JSON-Frame an Ihren Code. Mit sgcWebSockets verbindet TsgcChatTransport_WebSocket einen Client, und TsgcChatServer_WebSocket leitet die Nachrichten zwischen den Clients eines Kanals weiter, verwaltet die Präsenz jedes Benutzers und sendet die letzten Nachrichten an Benutzer, die später beitreten. Das Relay läuft in einem Dienst oder in einem Konsolenprogramm:

function CreateRelay(aOwner: TComponent; aPort: Integer)
  : TsgcChatServer_WebSocket;
var
  oServer: TsgcWebSocketServer;
begin
  oServer := TsgcWebSocketServer.Create(aOwner);
  oServer.Port := aPort;
  // the relay needs no main thread
  oServer.NotifyEvents := neNoSync;

  Result := TsgcChatServer_WebSocket.Create(aOwner);
  Result.Server := oServer;
  // the last 100 messages of every channel go to late joiners
  Result.HistoryCount := 100;

  oServer.Active := True;
end;

Beide Delphi-Beispiele oben sind unverändert aus den Hilfebeispielen von sgcChat übernommen, die mit Delphi 13 (Win32) gegen die Quellen von sgcUI und sgcWebSockets kompiliert wurden.

Der WebSocket-Team-Chat benötigt sgcWebSockets, das in All-Access enthalten ist. TsgcChatTransport_WebSocket und TsgcChatServer_WebSocket befinden sich im Bridge-Paket sgcChatWS (.NET: esegece.sgcChat.sgcWebSockets). Ohne sgcWebSockets verbindet TsgcChatEventTransport den Chat mit jedem Backend.

sgcChat: ein nativer Markdown-Viewer

Die Engine hinter den Chat-Blasen ist auch ein eigenes Steuerelement. TsgcVCLMarkdownViewer und TsgcFMXMarkdownViewer zeigen Überschriften, Hervorhebungen, Zitate, Listen, Aufgabenlisten, Tabellen, Links und Bilder an und heben die Codeblöcke von Pascal, C#, C++, JavaScript, Python, JSON, SQL und weiteren Sprachen hervor. AppendMarkdown fügt Text hinzu, sobald er eintrifft, und Benutzer markieren und kopieren den Text oder einen ganzen Codeblock über dessen Kopieren-Schaltfläche. Verwenden Sie ihn für Release Notes, Hilfeseiten und in Markdown verfasste Nachrichten.

Der sgcChat-Markdown-Viewer im hellen Theme
Markdown-Viewer, hell
Der sgcChat-Markdown-Viewer im dunklen Theme
Markdown-Viewer, dunkel

sgcChat passt zum Rest der Suite

Der Chat folgt den Themes Hell, Dunkel und Fluent von sgcUI. Eine Unterhaltung auf Arabisch oder Hebräisch wird gespiegelt, und die Texte der Steuerelemente sind in die 12 sgcUI-Sprachen übersetzt. Unter Windows ist die Chat-Ansicht für Screenreader eine Liste von Nachrichten, mit dem Autor und der Uhrzeit jeder Nachricht. Das Unterhaltungsmodell, das Markdown-Dokument und die Ansicht sind nicht von VCL oder FireMonkey abhängig, sodass ein Dienst eine Unterhaltung oder ein Markdown-Dokument ohne Fenster als SVG oder PNG rendern kann, auch unter Linux64.

Die Komponenten sind TsgcVCLChatPanel, TsgcVCLChatView, TsgcVCLChatInput und TsgcVCLMarkdownViewer, derselbe Satz mit dem Präfix TsgcFMX für FireMonkey und dieselben Steuerelemente für WinForms, WPF und Avalonia, etwa TsgcWinFormsChatPanel, TsgcWpfChatPanel und TsgcAvaloniaChatPanel. Die Demos decken einen KI-Assistenten, einen Team-Chat-Client mit seinem Relay-Server und den Markdown-Viewer ab, für VCL, FireMonkey, C++ Builder, WinForms, WPF und Avalonia.

sgcChat wird als Teil von sgcUI Enterprise und des All-Access-Pakets verkauft, das auch sgcWebSockets für den KI-Provider und die WebSocket-Bridge enthält. Siehe die sgcChat-Seite und die Funktionsmatrix.

sgcSpreadsheet: eine Tabellenkalkulation im Excel-Stil

sgcSpreadsheet ist das siebzehnte sgcUI-Produkt. Es ist ein Tabellenkalkulations-Steuerelement, das auf sgcGrid und einer über sgcUICore geteilten Formel-Engine aufbaut: TsgcVCLSpreadsheet für VCL, TsgcFMXSpreadsheet für FireMonkey, dazu jeweils eine Formelleiste, sowie TsgcWinFormsSpreadsheet, TsgcWpfSpreadsheet und TsgcAvaloniaSpreadsheet für .NET.

Es wertet 211 Arbeitsblattfunktionen aus, von Mathematik, Statistik, Text und Datum bis zu Nachschlagefunktionen mit XLOOKUP und dynamischen Arrays wie SEQUENCE, SORT, FILTER und UNIQUE. Ein Abhängigkeitsgraph berechnet nur die Zellen neu, die sich ändern, dynamische Arrays laufen in die Nachbarzellen über, und die Blätter unterstützen definierte Namen, mehrere Blätter, fixierte Bereiche und eigene Funktionen, die Ihre Anwendung registriert. Diagramme entstehen aus Zellbereichen in 7 Diagrammtypen, gezeichnet mit sgcCharts, und die Arbeitsmappe lädt und speichert XLSX-Dateien, Diagramme eingeschlossen.

sgcSpreadsheet ist in sgcUI Enterprise und im All-Access-Bundle enthalten und wird außerdem als Einzelpaket für Delphi und für .NET verkauft. Die Installation installiert auch sgcGrid und sgcCharts. Siehe die sgcSpreadsheet-Seite und die Feature-Liste.

In der ganzen Suite: Eingabe, Daten und Ausgabe

Der Rest der Version schließt kleinere Lücken in den Produkten: Steuerelemente, die Benutzereingaben entgegennehmen, Datenbindung, die dem Dataset in beide Richtungen folgt, und mehr Wege, einen Bildschirm aus der Anwendung herauszubringen.

sgcGauges: Eingabe-Instrumente und Skins

Vier Eingabe-Instrumente, TsgcVCLKnobGauge, TsgcVCLSliderGauge, TsgcVCLToggleSwitchGauge und TsgcVCLPushButtonGauge (TsgcFMX in FireMonkey und dieselben Namen in WinForms, WPF und Avalonia), lassen den Benutzer einen Wert mit der Maus, per Touch, mit dem Mausrad oder über die Tastatur festlegen. OnUserChange wird nur bei Änderungen durch den Benutzer ausgelöst, und Screenreader erkennen sie als Schieberegler, Kippschalter und Schaltfläche. sgcGauges hat jetzt sechzehn Instrumenttypen, mit den Tank- und Prozesssymbol-Gauges des HMI-Pakets weiter unten.

Skin gibt jedem Instrument ein neues Aussehen: Classic, Modern, Industrial, ISA101, Dark oder einen eigenen Skin, der mit sgcGaugesRegisterSkin registriert wird. TsgcGaugeDataLink zeigt ein Dataset-Feld auf jedem Instrument an und schreibt die Änderungen eines Eingabe-Instruments in das Feld zurück. Siehe die Funktionen von sgcGauges und die Hilfe zu den Eingabe-Instrumenten.

Live-Datenbindung und Datenbindung in beide Richtungen

Die Produkte folgen einem Delphi-TDataSet oder einer DataTable in .NET, während es sich ändert, und die bearbeitenden Produkte schreiben die Änderungen des Benutzers zurück:

sgcDiagram, sgcPivotGrid, sgcGauges und sgcDashboard haben dieselbe Bindung in .NET. Die sgcUI-Funktionsmatrix listet auf, was jede Edition enthält.

sgcPlanner: Outlook-Serien, Google-Erinnerungen und Kapazität

TsgcPlannerGraphSync übernimmt jetzt Outlook-Serientermine als einen wiederkehrenden Eintrag mit seiner RRULE, geänderte Vorkommen als geänderte Vorkommen und abgesagte als Ausnahmen und sendet im Planer erstellte Serien zurück an Outlook. TsgcPlannerGoogleSync sendet im Planer geänderte Erinnerungen an Google Calendar, wenn ein Termin aktualisiert wird, und liest die in Google geänderten zurück. Eine Capacity pro Ressource (1 für eine Vollzeitkraft, 0,5 für eine Halbzeitkraft, 3 für ein Team aus drei Personen) steuert die Kapazitätslinie des Auslastungshistogramms und wird in Microsoft Project XML als MaxUnits gelesen und geschrieben. Siehe die Funktionen von sgcPlanner.

sgcDashboard: Im Web veröffentlichen und die Karten-Kachel überall

SaveToHTML schreibt ein Dashboard als eine eigenständige HTML-Seite. Jede Kachel wird vom selben Code, der sie druckt, als SVG gezeichnet, auf einem CSS-Raster, das den Breakpoints des Dashboards folgt, und jede Kachel hat eine Überschrift und eine Textalternative für Screenreader. Ohne Refresh-URL enthält die Seite überhaupt kein Skript. In .NET gibt es die Karten-Kachel jetzt auch für WPF und Avalonia, und Karten erscheinen in der Druck-, PDF- und HTML-Ausgabe des Dashboards. Lesen Sie die Hilfe zum Veröffentlichen im Web und die Funktionen von sgcDashboard.

sgcMaps: die Karte auf jedes Canvas zeichnen

DrawTo bei TsgcVCLMap, TsgcFMXMap und dem WinForms-SgcMapControl zeichnet die aktuelle Ansicht mit ihren geladenen Kacheln in ein Rechteck eines beliebigen sgcUI-Canvas, und auch die WPF- und Avalonia-Karten rendern auf jedes sgcUI-Canvas. So gelangt eine Karte in einer Dashboard-Kachel in den Druck, das PDF und die HTML-Seite. Siehe die Funktionen von sgcMaps.

sgcWizard: Übergänge und eine Zusammenfassungsseite

Transition animiert den Seitenwechsel mit einem Slide, einem Fade oder beidem, in Rechts-nach-links-Layouts gespiegelt, und ReduceMotion folgt der Animationseinstellung von Windows. Mit ShowSummary fügt der Assistent eine letzte Seite hinzu, die die Felder und die Werte auflistet, die der Benutzer auf jeder besuchten Seite eingegeben hat, mit maskierten Passwörtern und einem Link Bearbeiten, der zu jeder Seite zurückführt. Siehe die Funktionen von sgcWizard und die Hilfe zur Zusammenfassungsseite.

sgcReports: Skripte und die FireMonkey-Vorschau auf jeder Plattform

TsgcReport.Script enthält Prozeduren in einer kleinen Pascal-ähnlichen Sprache, gespeichert in der Berichtsdefinition und im JSON. Der Bericht führt ein Skript beim Start und beim Ende aus sowie vor und nach dem Drucken jedes Bands und jedes Elements, sodass ein Skript ein Band ausblenden oder den Text, die Schriftfarbe oder die Höhe eines Elements für den aktuellen Druck ändern kann. Die Designer von VCL, FireMonkey, WinForms, WPF und Avalonia bearbeiten das Skript mit einer Schaltfläche Prüfen, die Zeile und Spalte eines Fehlers anzeigt. Die FireMonkey-Vorschau läuft unter Windows, macOS, iOS und Android, mit Touch-Verschieben und Pinch-Zoom, und unter iOS und Android öffnen Drucken und Als PDF speichern das Freigabeblatt des Systems. Bänder und Elemente haben außerdem die Eigenschaft Bookmark, eine Textvorlage, die der PDF-Gliederung bei jedem Druck des Bands einen Eintrag hinzufügt, verschachtelt nach Gruppenebene, und die Vorschauen zeigen die Gliederung in einem Bereich (ShowOutline). Elemente haben außerdem die Eigenschaft Hyperlink, Bänder und Elemente die Eigenschaft Anchor, beides Textvorlagen: ein Web- oder mailto-Link oder #name, um zu einem Anker zu springen. Die Links bleiben im PDF-Export klickbar, mit Tags für PDF/UA und PDF/A-3a, und bleiben in HTML (Links und Element-IDs), Word DOCX (Hyperlinks und Lesezeichen) und Excel XLSX (Zellen-Hyperlinks) erhalten, in allen Editionen. Elemente haben außerdem eine Auflistung Highlights mit bedingten Stilen, jeweils ein Ausdruck Condition und ein StyleName: Bei jedem Druck des Elements ersetzt das erste Highlight, dessen Bedingung wahr ist, den Stil des Elements, zum Beispiel negative Beträge in Rot, ohne Skript, in allen Editionen. Die Engine hat außerdem ein Ereignis OnProgress mit den Seiten- und Datensatzzählern und eine Methode Cancel, geprüft zwischen den Bändern: Die Vorschauen zeigen den Fortschritt mit einer Schaltfläche Abbrechen (auch Esc), das Schließen des Fensters bricht einen langen Bericht ab, und der HTTP-Endpunkt hat die Grenzen MaxPages und Timeout und antwortet mit 503, wenn ein Bericht abgebrochen wird, in allen Editionen. Die Ausdrücke wachsen auf 68 Funktionen und 10 Aggregate, in allen Editionen einschließlich Community: Datumsarithmetik, Auffüllen und Formatieren, Choose und InList, ToWords für Zahlen in Worten in den 12 Sprachen von sgcUI, SumIf und CountIf sowie Previous, RunningSum und RunningCount, die mit jeder Gruppe neu beginnen. Siehe die Funktionen von sgcReports und die Hilfe zu Skripten. Der PDF-Export schreibt auch eine E-Rechnung: Das von der Anwendung gelieferte Rechnungs-XML (Factur-X, ZUGFeRD oder XRechnung) wird über die neue Eigenschaft EInvoice als zugehörige PDF/A-3-Datei mit den Factur-X-Metadaten eingebettet, auch zusammen mit PDF/A-3a und PDF/UA, in jeder Edition. sgcReports erzeugt das XML nicht. Zusammen mit sgcSign, das echte Rechnungen erstellt, signiert und einreicht, erhalten Sie beides in einer Datei.

Berichtsdefinitionen können jetzt von einer Basisdefinition erben. Die Basis ist eine Vorlage, die enthält, was viele Berichte gemeinsam haben, zum Beispiel einen Briefkopf. Ein abgeleiteter Bericht nennt sie über die neue Eigenschaft InheritsFrom ("inheritsFrom" im JSON) und speichert nur das, was anders ist, sodass ein Briefkopf Rechnungen, Kontoauszüge und Lieferscheine versorgt. Seiten, Bänder, Elemente und Stile werden nach Namen zusammengeführt, und beim Speichern eines abgeleiteten Berichts werden nur die Unterschiede zur Basis geschrieben. Das ist der Briefkopf:

{"format": "sgcReports", "version": 1, "report": {
  "pages": [{"name": "Page1", "bands": [
    {"name": "PageHeader", "bandType": "rbtPageHeader", "height": 20, "items": [
      {"name": "Logo", "width": 80, "height": 6, "text": {"text": "ACME Ltd."}},
      {"name": "DocTitle", "left": 120, "width": 60, "height": 6, "text": {"text": "DOCUMENT"}}]},
    {"name": "PageFooter", "bandType": "rbtPageFooter", "height": 10, "items": [
      {"name": "PageNo", "width": 40, "height": 5, "text": {"text": "Page [Page]"}}]}]}],
  "title": "Letterhead", "author": "ACME Ltd."}}

und das ist die Rechnung, die den Text von DocTitle ändert, das Element Number hinzufügt und das Band Detail hinzufügt:

{"format": "sgcReports", "version": 1, "report": {
  "inheritsFrom": "letterhead.json",
  "pages": [{"name": "Page1", "bands": [
    {"name": "PageHeader", "items": [
      {"name": "DocTitle", "text": {"text": "INVOICE"}},
      {"name": "Number", "left": 120, "top": 7, "width": 60, "height": 5, "text": {"text": "[Invoice.No]"}}]},
    {"name": "PageFooter"},
    {"name": "Detail", "bandType": "rbtMasterData", "height": 6, "dataSourceName": "Lines", "items": [
      {"name": "Description", "width": 120, "height": 5, "text": {"text": "[Lines.Description]"}}]}]}],
  "title": "Invoice"}}

Das Modell, die JSON-Definitionen und die Fluent-API sind in jeder Edition enthalten, auch in Community, und die Designer und der HTTP-Endpunkt unterstützen es in der Edition Registered. Siehe die Hilfe zur Berichtsvererbung.

Die VCL- und FireMonkey-Vorschauen haben nach Als PDF speichern drei neue Schaltflächen. Suchen zeigt eine Suchleiste mit Zurück und Weiter, Groß-/Kleinschreibung und Ganzes Wort und hebt jeden Treffer hervor (Ctrl+F, Enter und F3 funktionieren wie in einem Browser). Miniaturen zeigt die Seiten als kleine Bilder, die erst gerendert werden, wenn sie sichtbar werden. Export öffnet ein Menü mit PDF, Excel, CSV, PNG, HTML und Word. Das Ereignis OnExport wird vor jedem Export ausgelöst, sodass die Anwendung die Optionen der Exportkomponente setzen, den Dateinamen ändern oder den Export abbrechen kann. Die Schaltflächen sind in jeder Edition enthalten, auch in Community, und der Word-Eintrag benötigt die Edition Registered. Dieser Handler benennt das Excel-Blatt und bricht den CSV-Export ab. Siehe die Hilfe zur Vorschau.

procedure TMainForm.sgcPreviewExport(Sender: TObject;
  aFormat: TsgcReportPreviewExportFormat; aExport: TComponent;
  var aFileName: string; var aCancel: Boolean);
begin
  case aFormat of
    rpxXLSX:
      // set the options of the export before it writes
      TsgcReportXLSXExport(aExport).SheetName := 'Orders';
    rpxCSV:
      // no CSV files from this preview
      aCancel := True;
  end;
end;

procedure TMainForm.ExportReport;
begin
  // the Export menu offers PDF, Excel and HTML only
  sgcPreview.ExportFormats := [rpxPDF, rpxXLSX, rpxHTML];
  sgcPreview.OnExport := sgcPreviewExport;
  sgcPreview.Prepare;
  // export without the dialog
  sgcPreview.ExportToFile(rpxPDF, 'report.pdf');
  sgcPreview.ExportToFile(rpxXLSX, 'report.xlsx');
  // False: OnExport cancelled the CSV
  if not sgcPreview.ExportToFile(rpxCSV, 'report.csv') then
    Caption := 'CSV cancelled';
end;

procedure TMainForm.ExportHTML;
begin
  // the save dialog, then ExportToFile, as the menu item does
  sgcPreview.ExportWithDialog(rpxHTML);
end;

Reports nehmen Parameter entgegen. Ein Report deklariert typisierte Parameter (Text, Ganzzahl, Zahl, Datum, Datum und Uhrzeit, Ja oder Nein) mit Standardwert oder Standardausdruck, Pflichtwerten und Mehrfachwerten sowie einer Werteliste aus einer statischen Liste oder einer Datenquelle. Ausdrücke lesen sie als :Name, und eine Dataset-Quelle mit BindParameters gibt sie an die SQL-Parameter ihrer Abfrage weiter, sodass die Datenbank nur die Zeilen des Bereichs liefert. Die VCL- und FireMonkey-Vorschauen und -Designer fragen die Werte ab, bevor der Report vorbereitet wird, der HTML-Viewer zeigt ein typisiertes Formular, und der HTTP-Endpunkt bindet ?param.Name=value und antwortet bei einem ungültigen Wert mit 400. Parameter sind in jeder Edition enthalten, auch in Community, und der HTTP-Endpunkt erfordert sgcWebSockets Professional oder höher. Dieser Report deklariert einen Datumsbereich und eine Kundenliste:

{"format": "sgcReports", "version": 1, "report": {
  "pages": [{"name": "Main", "bands": [
    {"name": "Title", "bandType": "rbtReportTitle", "height": 8, "items": [
      {"name": "Caption", "width": 180, "height": 6,
       "text": {"text": "Sales from [:From] to [:To]"}}]},
    {"name": "OrderLine", "bandType": "rbtMasterData", "height": 6,
     "dataSourceName": "Orders",
     "visibleExpression": "IsNull(:Customers) or InList(Orders.CustomerID, :Customers)",
     "items": [
      {"name": "Order", "width": 180, "height": 5,
       "text": {"text": "[Orders.ID] [Orders.OrderDate] customer [Orders.CustomerID]: [Orders.Amount]"}}]}]}],
  "parameters": [
    {"name": "From", "caption": "From date", "dataType": "rpdtDate", "required": true,
     "defaultExpression": "AddMonths(Date, -1)"},
    {"name": "To", "caption": "To date", "dataType": "rpdtDate", "defaultExpression": "Date"},
    {"name": "Customers", "caption": "Customers", "dataType": "rpdtInteger", "multiValue": true,
     "listSourceName": "Customers", "listValueField": "ID", "listDisplayField": "Name"}]}}

Derselbe Report über HTTP ausgeliefert, mit der Ausgabe des kompilierten Beispiels. Siehe die Hilfe zu Report-Parametern.

GET /reports/sales.pdf?param.From=2026-01-01   200 application/pdf
GET /reports/sales.csv?param.From=2026-01-01   200
Sales from 01/01/2026 to 03/11/2026
2 10/01/2026 customer 2: 250
3 05/02/2026 customer 1: 75
4 15/03/2026 customer 3: 300
GET /reports/sales.csv?param.From=yesterday    400 Parameter "From": invalid date value

Reports haben jetzt ein Tabellenelement. Es hat Spalten, Kopf-, Daten- und Fußzeilen, verbundene Zellen sowie für jede Zelle einen Stil, Hervorhebungen und einen Hyperlink. Eine datengebundene Tabelle hat eine eigene Datenquelle und druckt ihre Datenzeilen einmal pro Datensatz, mit den Summen in den Fußzeilen, und ihre Kopfzeilen werden auf jeder neuen Seite oder Spalte erneut gedruckt. Die Exporte schreiben echte Tabellen: getaggtes PDF, das PDF/UA besteht, eine HTML-Tabelle, eine Word-Tabelle, CSV und ein Excel-Raster mit verbundenen Zellen. Die Designer für VCL, FireMonkey, Web, WinForms, WPF und Avalonia bearbeiten das Raster. Tabellen sind in jeder Edition enthalten, auch in Community, und der Word-Export ist nur in Registered enthalten. Diese Tabelle hat eine Kopfzeile, eine Zeile pro Datensatz und eine Fußzeile mit der Anzahl und der Summe:

oDataSet.FieldDefs.Add('Product', ftString, 20);
oDataSet.FieldDefs.Add('Amount', ftFloat);
oDataSet.CreateDataSet;
oDataSet.AppendRecord(['Keyboard', 49.9]);
oDataSet.AppendRecord(['Monitor', 1250]);
oDataSet.AppendRecord(['Cable', 7.5]);
oSource.SourceName := 'Lines';
oSource.DataSet := oDataSet;

oReport.Units := ruPoints;
oStyle := oReport.Styles.Add;
oStyle.Name := 'Head';
oStyle.Font.Bold := True;
oBand := oReport.Pages.Add.Bands.Add;
oBand.BandType := rbtReportTitle;
oBand.Height := 20;
oBand.CanGrow := True;
oItem := oBand.Items.Add;
oItem.Name := 'Lines';
oItem.Kind := rikTable;
oItem.Width := 300;
oItem.Table.DataSourceName := 'Lines';
oItem.Table.Columns.Add.Width := 30;
oItem.Table.Columns.Add.Width := 170;
oItem.Table.Columns.Add.Width := 100;
// a header row, one data row per record and a footer row with the totals
oRow := oItem.Table.Rows.Add;
oRow.Kind := rtrkHeader;
oRow.StyleName := 'Head';
oRow.Cells.Add.Text := '#';
oRow.Cells.Add.Text := 'Product';
oRow.Cells.Add.Text := 'Amount';
oRow := oItem.Table.Rows.Add;
oRow.Cells.Add.Text := '[Line]';
oRow.Cells.Add.Text := '[Lines.Product]';
oCell := oRow.Cells.Add;
oCell.Text := '[Lines.Amount]';
oCell.DisplayFormat := '#,##0.00';
oRow := oItem.Table.Rows.Add;
oRow.Kind := rtrkFooter;
oRow.StyleName := 'Head';
oRow.Cells.Add.Text := '';
oRow.Cells.Add.Text := 'Total ([Count()] lines)';
oCell := oRow.Cells.Add;
oCell.Text := '[Sum(Lines.Amount)]';
oCell.DisplayFormat := '#,##0.00';

oEngine.Report := oReport;
oEngine.AddDataSource(oSource);
oPages := oEngine.Prepare;
try
  for i := 0 to oPages.Count - 1 do
    for j := 0 to oPages[i].Count - 1 do
      if Assigned(oPages[i][j].Cell) then
        WriteLn('row ', oPages[i][j].Cell.Row, ' col ',
          oPages[i][j].Cell.Column, ': ', Trim(oPages[i][j].Lines.Text));
finally
  oPages.Free;
end;

Das Programm schreibt den Text jeder Zelle, was diese Ausgabe ergibt. Siehe die Hilfe zu Tabellen.

row 0 col 0: #
row 0 col 1: Product
row 0 col 2: Amount
row 1 col 0: 1
row 1 col 1: Keyboard
row 1 col 2: 49.90
row 2 col 0: 2
row 2 col 1: Monitor
row 2 col 2: 1,250.00
row 3 col 0: 3
row 3 col 1: Cable
row 3 col 2: 7.50
row 4 col 0:
row 4 col 1: Total (3 lines)
row 4 col 2: 1,307.40

Berichte haben vier weitere Elementarten. Ein Kontrollkästchen-Element wird von einem booleschen Ausdruck wie Orders.Paid angehakt, der für jeden Datensatz ausgewertet wird, mit Häkchen, Kreuz oder ausgefülltem Quadrat. Es wird im PDF als Vektorpfade gedruckt (eine Figure im getaggten PDF/UA), im HTML als Inline-SVG, im DOCX als Symbol und in XLSX und CSV als Wert TRUE oder FALSE. Ein Bildelement druckt jetzt SVG-Bilder, die im PDF Vektorgrafik bleiben und keine neue Eigenschaft brauchen. Beide sind in jeder Edition enthalten, auch in Community; die .NET-Community-Edition druckt SVG im HTML, aber nicht im PDF. Die registrierte Edition ergänzt ein Sparkline-Element, das sgcCharts zeichnet, und ein Gauge-Element, das sgcGauges zeichnet, als zwei Brücken, die diese Produkte benötigen. Dieser Bericht druckt pro Bestellung zwei Kontrollkästchen, eines für die bezahlten Bestellungen und ein rotes Kreuz für die Beträge über 100, und speichert die Seiten in jedem Format:

oSource.SourceName := 'Orders';
oSource.JSON := '[{"Id":1,"Paid":true,"Amount":250},' +
  '{"Id":2,"Paid":false,"Amount":80}]';
oBand := oBuilder.Page('Main').MasterData('Orders', 8);
// checked when the field Paid is true
oBand.CheckBox('Orders.Paid', 0, 0, 5, 5);
// a red cross when the amount is over 100
oBand.CheckBox('Orders.Amount > 100', 10, 0, 5, 5);
oBand.Item.CheckBox.CheckStyle := rcsCross;
oBand.Item.CheckBox.CheckColor := $C00000;
oEngine.Report := oBuilder.Report;
oEngine.AddDataSource(oSource);
oPages := oEngine.Prepare;
try
  for i := 0 to oPages[0].Count - 1 do
    if oPages[0][i].Kind = rpkCheckBox then
      WriteLn(oPages[0][i].ItemName, ': ',
        BoolToStr(oPages[0][i].Checked, True));
  // vector glyphs, tagged as Figure
  oPDF.PDFUA := True;
  oPDF.Title := 'Orders';
  oPDF.SaveToFile(oPages, 'orders.pdf');
  // an inline svg with role img per check box
  oHTML.SaveToFile(oPages, 'orders.html');
  // Wingdings symbols
  oDOCX.Mode := dmFixed;
  oDOCX.SaveToFile(oPages, 'orders.docx');
  // boolean cells
  oXLSX.SaveToFile(oPages, 'orders.xlsx');
  // TRUE and FALSE
  Write(oCSV.GetCSV(oPages));
finally
  oPages.Free;
end;

Das Programm schreibt den gedruckten Wert jedes Kontrollkästchens, danach den CSV-Text. Siehe die Hilfe zum Kontrollkästchen.

CheckBox1: True
CheckBox2: True
CheckBox1: False
CheckBox2: False
TRUE,TRUE
FALSE,FALSE

sgcReports importiert jetzt Berichte aus anderen Produkten. TsgcReportImporter liest einen FastReport-VCL-Bericht (.fr3), ein QuickReport-Formular (.dfm mit einem TQuickRep) oder eine ReportBuilder-Vorlage (.rtm), als Text oder binär, und wandelt ihn in eine Berichtsdefinition um: Seiten, Bänder, Elemente, Stile, Datenfelder und Ausdrücke. An dem, was er nicht kennt, scheitert er nie. Jedes Objekt, jede Eigenschaft, jeder Ausdruck und jedes Skript, das nicht zugeordnet werden konnte, wird als Problem aufgelistet, mit dem Pfad im Bericht und dem Originaltext, sodass Sie wissen, was zu korrigieren ist. Die Designer für VCL, FireMonkey, WinForms, WPF und Avalonia haben einen Befehl Importieren, und eine Demo konvertiert eine Datei. Der Importer ist in der registrierten Edition enthalten. Dieser Code importiert ein QuickReport-Formular, benennt dessen Datenmenge um, gibt die Probleme aus und speichert die JSON-Definition:

oReport := TsgcReport.Create(nil);
oImporter := TsgcReportImporter.Create;
try
  // QuickReport data set = sgcReports data source
  oImporter.DataSourceMap.Values['tblCustomers'] := 'Customers';
  oImporter.ImportFromFile(oReport, 'qr_list.dfm');
  WriteLn(Format('%d pages, %d bands, %d items, %d styles, %d issues',
    [oImporter.ImportResult.PageCount, oImporter.ImportResult.BandCount,
    oImporter.ImportResult.ItemCount, oImporter.ImportResult.StyleCount,
    oImporter.ImportResult.Issues.Count]));
  for i := 0 to oImporter.ImportResult.Issues.Count - 1 do
  begin
    oIssue := oImporter.ImportResult.Issues[i];
    WriteLn(GetEnumName(TypeInfo(TsgcReportImportIssueKind),
      Ord(oIssue.Kind)), ' ', oIssue.Path, ' ', oIssue.PropertyName, ': ',
      oIssue.Reason);
  end;
  sgcReportSaveToJSONFile(oReport, 'qr_list.json');
finally
  oImporter.Free;
  oReport.Free;
end;

Das Programm gibt die Anzahlen und die Probleme des Beispielformulars aus, das ergibt diese Ausgabe. Die Datenquelle, das Skript und das Rich-Text-Element konnte der Importer nicht übernehmen. Siehe die Hilfe zum Importer.

1 pages, 5 bands, 11 items, 3 styles, 3 issues
riiScript QuickRep1 BeforePrint: Event handler not converted
riiDataSource QuickRep1/DetailBand1 : Add a data source with SourceName Customers
riiObject QuickRep1/PageFooterBand1/QRRichText1 : Object type not supported

sgcPDF für .NET: Annotationen bearbeiten und Formulare ausfüllen in WPF und Avalonia

Die WPF- und Avalonia-Viewer können jetzt, was der WinForms-Viewer kann: Benutzer erstellen, verschieben, ändern, bearbeiten und löschen Annotationen mit der Maus (AnnotationEditing und AnnotationTool), und mit FormFilling füllen sie Textfelder, Kontrollkästchen, Optionsfelder, Kombinationsfelder und Listenfelder aus, wobei die Tabulatortaste in Tabulatorreihenfolge durch die Felder springt. Siehe die Funktionen von sgcPDF.

Barrierefreiheit auf jeder Plattform geprüft

Der UI-Automation-Baum jeder Produkt-Demo, also der Baum, den Screenreader wie Narrator und NVDA lesen, wurde mit einem UI-Automation-Client unter VCL, FireMonkey, WinForms, WPF und Avalonia geprüft, und die gefundenen Probleme wurden behoben. Die VCL-Editoren melden jetzt die Beschriftung des Feldes statt seines Wertes, eine flache Navigationsleiste ist eine Liste statt eines Baums, die WinForms- und WPF-Statusleisten nehmen nicht mehr den Tastaturfokus an, die Zellen des Avalonia-Grids wiederholen ihren Spaltennamen nicht mehr, und die Diagrammpunkte und andere gezeichnete Elemente der Avalonia-Steuerelemente melden ihre Position auf dem Bildschirm.

Visual Studio Smart Tags und XAML

Die Smart Tags aller 69 WinForms-Toolbox-Komponenten wurden auf einer Designfläche getestet: jede Eigenschaft, jeder Collection-Editor, jede Datenquellenliste, jede Aktion und jedes Verb. In WPF und Avalonia werden die Kacheln von sgcDashboard und die Skins von sgcGauges in XAML unter demselben Präfix sgc deklariert wie die Spalten, Felder und Serien der anderen Produkte.

sgcEditors: Layout-Steuerelement und Datenformulare

Das neue Layout-Steuerelement, TsgcVCLLayoutControl und TsgcFMXLayoutControl (und dieselben Namen unter WinForms, WPF und Avalonia), ordnet die Steuerelemente eines Formulars in Gruppen, Gruppen mit Registerkarten und Spalten an, mit auf eine Breite ausgerichteten Beschriftungen, Teilern, die der Benutzer ziehen kann, und Rechts-nach-links-Layouts. SaveLayout und LoadLayout sichern die vom Benutzer erstellte Anordnung als JSON. Das Layout-Steuerelement ist in jeder Edition enthalten, auch in Community. Delphi Community hat kein Design-Time-Paket für sgcEditors, daher wird es dort im Code erzeugt.

Das Datenformular baut darauf auf. TsgcVCLDataForm und TsgcFMXDataForm erzeugen ein vollständiges Bearbeitungsformular aus einem TDataSet oder aus den published-Eigenschaften einer Klasse mit BindObject, und die Datenformulare für WinForms, WPF und Avalonia nehmen eine DataTable, eine Liste oder ein Objekt entgegen. Jedes Feld erhält ein sgcEditors-Steuerelement, die Regeln des sgcUICore-Validators und einen Platz in einer Gruppe oder auf einer Registerkarte, und ein Navigator blättert, fügt hinzu, bearbeitet, löscht und speichert die Datensätze. Smart Paste füllt den ganzen Datensatz aus einem eingefügten Text über die KI-Schicht, die die Editoren bereits verwenden, und markiert die Felder, die es ausgefüllt hat. Das Datenformular ist in der Registered-Edition enthalten, unter VCL, FireMonkey, C++Builder, WinForms, WPF und Avalonia:

uses
  Forms, Controls, DB,
  sgcUICore_AI, sgcEditors_DataForm, sgcEditors_VCL_DataForm;

function CreateCustomerForm(aOwner: TForm; aSource: TDataSource;
  aProvider: TsgcUIAIProvider): TsgcVCLDataForm;
var
  oField: TsgcDataFormField;
begin
  Result := TsgcVCLDataForm.Create(aOwner);
  Result.Parent := aOwner;
  Result.Align := alClient;
  // an open dataset: one field, one editor and one rule per TField
  Result.DataSource := aSource;
  oField := Result.Fields.FindField('EMAIL');
  oField.Kind := edfEmail;
  oField.Required := True;
  oField.Group := 'Contact';
  Result.Fields.FindField('PHONE').Group := 'Contact';
  Result.RebuildEditors;
  // the Smart Paste button of the navigator fills every field from the
  // clipboard; without a provider a local parser reads "Name: value" lines
  Result.Provider := aProvider;
end;

Siehe die sgcEditors-Funktionen und die Hilfe zum Datenformular.

sgcUI HMI-Paket: Tanks, P&ID, Alarme und ein NumPad

Das HMI-Paket bringt Prozessbilder zu sgcUI: Bedienpanels, Tanklager, Pumpstationen und andere Anlagendisplays. Es ist kein neues Produkt. Jeder Baustein steckt in dem Produkt, das er erweitert, und folgt dessen Edition, unter VCL und FireMonkey, C++ Builder sowie WinForms, WPF und Avalonia in .NET. Rufe einmal sgcUIApplyISA101 auf, und jedes sgcUI-Steuerelement wechselt auf das graue ISA-101-Schema, in dem Farbe für abnormale Zustände und Alarme reserviert bleibt.

Die Anwendung behält die Hoheit über die Anlage: Sie holt die Werte aus ihren eigenen Treibern, einer Datenbank oder der Gauge-Brücke, und sie entscheidet, wann ein Alarm ausgelöst wird. Es gibt keinen OPC-UA- oder Modbus-Treiber. Die Tank- und Prozesssymbol-Gauges, die Alarmliste und das NumPad sind in jeder Edition enthalten, auch in Community, während die P&ID-Schablonen, die Prozesszustände und animierten Rohrleitungen, die Gauge-Feeds und das Quittierungsprotokoll für Alarme Registered sind. Die HMI-Suite-Demo fügt die Bausteine auf einem kleinen Tanklager zusammen, das ein Simulator antreibt. Lies die Seite zum sgcUI HMI-Paket und die Hilfe zum HMI-Paket.

sgcUI Realtime-UI-Paket: Präsenz, Benachrichtigungen, Aktivitäts-Feeds und Live-Logs

Das Realtime-UI-Paket gibt sgcUI die Bausteine einer Live-Oberfläche für Delphi, C++Builder und .NET. Es ist kein neues Produkt. Jeder Baustein steckt in dem Produkt, das er erweitert. sgcUICore ergänzt ein Präsenzmodell mit Avataren, einer Avatar-Gruppe und einer Präsenzanzeige. sgcNavigation ergänzt ein Benachrichtigungscenter mit Toasts, einem nach Tagen gruppierten Posteingang und Einstellungen pro Kategorie und Kanal, während TsgcToolbarBadgeLink von sgcToolbar die Zahl der ungelesenen Meldungen an einem Toolbar- oder Ribbon-Eintrag anzeigt. sgcDashboard ergänzt einen Aktivitäts-Feed und einen Audit-Trail, als eigenständige Steuerelemente und als Dashboard-Kacheln, und sgcGrid ergänzt einen Live-Log-Viewer mit Stufen, Filtern, Ende-folgen, Pause und Export.

Jedes Modell nimmt pro Änderung eine JSON-Nachricht entgegen. In der Registered-Edition speisen die Live-Quellen WebSocket, MQTT und SSE der Brücke sgcUICoreWS sie ohne Code aus sgcWebSockets. Jedes Steuerelement kommt mit der Edition seines Produkts. Ohne Server oder in einem Community-Build aktualisiert die Anwendung die Modelle stattdessen über ihre API. Lies die Seite zum sgcUI Realtime-UI-Paket.

Getting-Started-Leitfäden für jedes Produkt

Jedes sgcUI-Produkt enthält jetzt fünf QuickStart-Demos für Delphi (VCL) und einen Getting-Started-Leitfaden, als HTML neben den Demos und als PDF (auf Englisch). Die Demos reichen vom ersten Formular bis zu einer kleinen, vollständigen Anwendung, und der Leitfaden erklärt jeden Schritt. Beginne mit dem sgcGrid-Leitfaden, dem sgcCharts-Leitfaden oder dem sgcChat-Leitfaden.

Alle 16 Leitfäden findest du im Abschnitt Leitfäden des sgcUI-Schnellstarts.

Testen Sie sgcChat und sgcUI 2026.11

Eine Testversion für Delphi und eine für C++ Builder installieren alle 17 sgcUI-Produkte.

Fragen oder Feedback? Nehmen Sie Kontakt auf, Sie erhalten eine Antwort von den Menschen, die den Code geschrieben haben.