sgcUI 2026.11: sgcChat, asistente de IA y chat de equipo para Delphi, C++ Builder y .NET

· Versiones
sgcUI 2026.11: sgcChat, asistente de IA y chat de equipo para Delphi y .NET | Blog de eSeGeCe
✦  Nueva versión · sgcUI 2026.11

Conoce sgcChat.
Un chat dentro de tu aplicación.

Un asistente de IA que muestra sus respuestas como Markdown con formato mientras se generan, y un chat de equipo con presencia, indicador de escritura, acuses de lectura y reacciones. Controles nativos para Delphi, C++ Builder y .NET.

También en YouTube.

  • VCL
  • FireMonkey
  • WinForms
  • WPF
  • Avalonia
  • SVG y PNG sin ventana
Una conversación con un asistente de IA y un chat de equipo, lado a lado, dibujados por sgcChat
17productos sgcUI
4controles de chat
5frameworks de interfaz
12idiomas

Hoy publicamos sgcUI 2026.11. Incorpora dos productos nuevos: sgcChat, que lleva un chat con asistente de IA y un chat de equipo al interior de tu propia aplicación, y sgcSpreadsheet, una hoja de cálculo estilo Excel. También cubre una lista de carencias menores en toda la suite: indicadores que aceptan entrada del usuario, un enlace de datos que sigue al conjunto de datos en ambos sentidos, un panel publicado como página web, series recurrentes de Outlook en el planificador, scripts en los informes y más.

sgcChat es el decimosexto producto de sgcUI. Funciona en VCL y FireMonkey para Delphi y C++ Builder, y en WinForms, WPF y Avalonia para .NET, y está incluido en sgcUI Enterprise y en All-Access. No se vende como paquete independiente.

sgcChat: un asistente de IA en tu aplicación

Una respuesta de IA llega en trozos pequeños, y los usuarios esperan leerla mientras se escribe. TsgcChatAI enlaza una conversación con un proveedor, envía el historial y el prompt del sistema, y muestra cada trozo como Markdown con formato en cuanto llega. El proveedor se ejecuta en un hilo de trabajo, de modo que la ventana sigue respondiendo, y el panel de chat ofrece detener, regenerar, y editar y reenviar para cada respuesta.

Una conversación con un asistente de IA en el panel de sgcChat
El asistente de IA en el panel de chat.

sgcChat no te ata a un único proveedor de IA. TsgcChatAIProvider_AIChat se conecta a TsgcAIChat de sgcWebSockets, que habla con OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok y Mistral. TsgcChatAIProvider_UICore usa la capa de proveedores de IA que comparten todos los productos sgcUI, y TsgcChatAIEventProvider te permite hacer streaming desde tu propio backend en un evento. Así responde con OpenAI un enlace TsgcChatAI:

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;

Cambia Provider para usar Anthropic, Gemini, DeepSeek, Ollama, Grok o Mistral. La ayuda de sgcChat incluye la guía de inicio rápido completa.

Hablar con Claude, OpenAI, Gemini y los demás proveedores de LLM requiere sgcWebSockets, incluido en All-Access. TsgcChatAIProvider_AIChat está en el paquete del puente sgcChatWS (.NET: esegece.sgcChat.sgcWebSockets). Sin sgcWebSockets, TsgcChatAIEventProvider permite que tu propio código llame a cualquier servicio de IA.

sgcChat: un chat de equipo en tu propio servidor

Los servicios de soporte, los equipos de campo y las herramientas internas necesitan un chat que sus usuarios ya sepan usar. La vista de chat agrupa los mensajes de cada autor con un avatar y un nombre, muestra quién está conectado, ausente u ocupado, muestra quién está escribiendo y marca cada mensaje como enviado, entregado o leído. Los usuarios responden a un mensaje, reaccionan a él, editan o eliminan sus propios mensajes y envían archivos adjuntos con miniaturas de imagen y etiquetas de archivo.

Un chat de equipo con avatares, presencia y acuses de lectura en sgcChat
Un chat de equipo con presencia, indicador de escritura y acuses de lectura.

El chat no depende de un servidor concreto. TsgcChatEventTransport entrega a tu código cada mensaje, cambio de escritura, acuse y reacción como una trama JSON documentada. Con sgcWebSockets, TsgcChatTransport_WebSocket conecta a un cliente y TsgcChatServer_WebSocket retransmite los mensajes entre los clientes de un canal, mantiene la presencia de cada usuario y envía los últimos mensajes a los usuarios que se incorporan más tarde. El relay se ejecuta en un servicio o en un programa de consola:

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;

Los dos ejemplos de Delphi anteriores están copiados sin cambios de los ejemplos de la ayuda de sgcChat, que se compilaron con Delphi 13 (Win32) contra los fuentes de sgcUI y sgcWebSockets.

El chat de equipo por WebSocket requiere sgcWebSockets, incluido en All-Access. TsgcChatTransport_WebSocket y TsgcChatServer_WebSocket están en el paquete del puente sgcChatWS (.NET: esegece.sgcChat.sgcWebSockets). Sin sgcWebSockets, TsgcChatEventTransport conecta el chat con cualquier backend.

sgcChat: un visor Markdown nativo

El motor que hay detrás de las burbujas del chat es también un control por sí mismo. TsgcVCLMarkdownViewer y TsgcFMXMarkdownViewer muestran encabezados, énfasis, citas, listas, listas de tareas, tablas, enlaces e imágenes, y resaltan los bloques de código de Pascal, C#, C++, JavaScript, Python, JSON, SQL y otros lenguajes. AppendMarkdown añade texto a medida que llega, y los usuarios seleccionan y copian el texto o un bloque de código completo con su botón de copiar. Úsalo para notas de versión, páginas de ayuda y mensajes escritos en Markdown.

El visor Markdown de sgcChat en el tema claro
Visor Markdown, claro
El visor Markdown de sgcChat en el tema oscuro
Visor Markdown, oscuro

sgcChat encaja con el resto de la suite

El chat sigue los temas claro, oscuro y Fluent de sgcUI. Una conversación en árabe o hebreo se muestra en espejo, y los textos de los controles están traducidos a los 12 idiomas de sgcUI. En Windows, la vista de chat es una lista de mensajes para los lectores de pantalla, con el autor y la hora de cada mensaje. El modelo de conversación, el documento Markdown y la vista no dependen de VCL ni de FireMonkey, así que un servicio puede renderizar una conversación o un documento Markdown a SVG o PNG sin ventana, también en Linux64.

Los componentes son TsgcVCLChatPanel, TsgcVCLChatView, TsgcVCLChatInput y TsgcVCLMarkdownViewer, el mismo conjunto con el prefijo TsgcFMX para FireMonkey, y los mismos controles para WinForms, WPF y Avalonia, como TsgcWinFormsChatPanel, TsgcWpfChatPanel y TsgcAvaloniaChatPanel. Las demos cubren un asistente de IA, un cliente de chat de equipo con su servidor relay y el visor Markdown, para VCL, FireMonkey, C++ Builder, WinForms, WPF y Avalonia.

sgcChat se vende como parte de sgcUI Enterprise y del paquete All-Access, que incluye además sgcWebSockets para el proveedor de IA y el puente WebSocket. Consulta la página de sgcChat y la matriz de características.

sgcSpreadsheet: una hoja de cálculo estilo Excel

sgcSpreadsheet es el producto número diecisiete de sgcUI. Es un control de hoja de cálculo construido sobre sgcGrid y un motor de fórmulas compartido a través de sgcUICore: TsgcVCLSpreadsheet para VCL, TsgcFMXSpreadsheet para FireMonkey, una barra de fórmulas para cada uno, y TsgcWinFormsSpreadsheet, TsgcWpfSpreadsheet y TsgcAvaloniaSpreadsheet para .NET.

Evalúa 211 funciones de hoja de cálculo, desde matemáticas, estadística, texto y fechas hasta búsquedas con XLOOKUP y matrices dinámicas como SEQUENCE, SORT, FILTER y UNIQUE. Un grafo de dependencias recalcula solo las celdas que cambian, las matrices dinámicas se desbordan en las celdas contiguas, y las hojas admiten nombres definidos, varias hojas, paneles inmovilizados y funciones personalizadas registradas por tu aplicación. Los gráficos se construyen a partir de rangos de celdas en 7 tipos de gráfico dibujados con sgcCharts, y el libro carga y guarda archivos XLSX, gráficos incluidos.

sgcSpreadsheet está incluido en sgcUI Enterprise y en el paquete All-Access, y también se vende como paquete individual para Delphi y para .NET. Al instalarlo se instalan sgcGrid y sgcCharts. Consulta la página de sgcSpreadsheet y la lista de características.

En toda la suite: entrada, datos y salida

El resto de la versión cubre carencias menores en los productos: controles que aceptan entrada del usuario, un enlace de datos que sigue al conjunto de datos en ambos sentidos y más formas de sacar una pantalla de la aplicación.

sgcGauges: indicadores de entrada y skins

Cuatro indicadores de entrada, TsgcVCLKnobGauge, TsgcVCLSliderGauge, TsgcVCLToggleSwitchGauge y TsgcVCLPushButtonGauge (TsgcFMX en FireMonkey, y los mismos nombres en WinForms, WPF y Avalonia), permiten al usuario fijar un valor con el ratón, el tacto, la rueda o el teclado. OnUserChange se dispara solo con los cambios hechos por el usuario, y los lectores de pantalla los ven como un control deslizante, un interruptor y un botón. sgcGauges tiene ahora dieciséis tipos de indicador, contando los indicadores de depósito y de símbolo de proceso del paquete HMI que se describe más abajo.

Skin da a cada indicador un aspecto nuevo: Classic, Modern, Industrial, ISA101, Dark o un skin propio registrado con sgcGaugesRegisterSkin. TsgcGaugeDataLink muestra un campo del conjunto de datos en cualquier indicador y escribe de vuelta en el campo los cambios de un indicador de entrada. Consulta las características de sgcGauges y la ayuda de los indicadores de entrada.

Enlace de datos en vivo y en dos sentidos

Los productos siguen un TDataSet de Delphi, o un DataTable en .NET, mientras cambia, y los productos de edición escriben de vuelta los cambios del usuario:

sgcDiagram, sgcPivotGrid, sgcGauges y sgcDashboard tienen el mismo enlace en .NET. La matriz de características de sgcUI indica qué incluye cada edición.

sgcPlanner: series de Outlook, recordatorios de Google y capacidad

TsgcPlannerGraphSync ahora trae las series recurrentes de Outlook como un único elemento recurrente con su RRULE, las ocurrencias modificadas como ocurrencias modificadas y las canceladas como excepciones, y envía de vuelta a Outlook las series creadas en el planificador. TsgcPlannerGoogleSync envía a Google Calendar los recordatorios cambiados en el planificador cuando se actualiza un evento, y lee los que se cambiaron en Google. Una Capacity por recurso (1 para una persona a tiempo completo, 0.5 para media jornada, 3 para un equipo de tres) controla la línea de capacidad del histograma de carga, y se lee y se escribe como MaxUnits en el XML de Microsoft Project. Consulta las características de sgcPlanner.

sgcDashboard: publicar en la web y el mosaico de mapa en todas partes

SaveToHTML escribe un panel como una única página HTML autocontenida. Cada mosaico se dibuja como SVG con el mismo código que lo imprime, sobre una cuadrícula CSS que sigue los puntos de ruptura del panel, y cada mosaico tiene un encabezado y una alternativa de texto para los lectores de pantalla. Sin una URL de actualización, la página no contiene ningún script. En .NET el mosaico de mapa existe ahora también para WPF y Avalonia, y los mapas aparecen en la impresión, el PDF y la salida HTML del panel. Lee la ayuda de publicar en la web y las características de sgcDashboard.

sgcMaps: dibuja el mapa en cualquier canvas

DrawTo en TsgcVCLMap, TsgcFMXMap y el SgcMapControl de WinForms dibuja la vista actual, con sus teselas cargadas, en un rectángulo de cualquier canvas de sgcUI, y los mapas de WPF y Avalonia se renderizan también en cualquier canvas de sgcUI. Así llega un mapa de un mosaico del panel a la impresión, al PDF y a la página HTML. Consulta las características de sgcMaps.

sgcWizard: transiciones y una página de resumen

Transition anima el cambio de página con un deslizamiento, un fundido o ambos, en espejo en los diseños de derecha a izquierda, y ReduceMotion sigue el ajuste de animaciones de Windows. Con ShowSummary el asistente añade una última página que lista los campos y los valores que el usuario introdujo en cada página visitada, con las contraseñas ocultas y un enlace Editar que vuelve a cada página. Consulta las características de sgcWizard y la ayuda de la página de resumen.

sgcReports: scripts y la vista previa de FireMonkey en todas las plataformas

TsgcReport.Script contiene procedimientos en un pequeño lenguaje parecido a Pascal, guardados en la definición del informe y en el JSON. El informe ejecuta un script al empezar y al terminar, y cada banda y cada elemento antes y después de imprimirse, de modo que un script puede ocultar una banda o cambiar el texto, el color de la fuente o la altura de un elemento en la impresión actual. Los diseñadores de VCL, FireMonkey, WinForms, WPF y Avalonia editan el script con un botón Comprobar que muestra la línea y la columna de un error. La vista previa de FireMonkey funciona en Windows, macOS, iOS y Android, con desplazamiento táctil y zoom con pellizco, y en iOS y Android, Imprimir y Guardar PDF abren la hoja de compartir del sistema. Las bandas y los elementos también tienen la propiedad Bookmark, una plantilla de texto que añade una entrada al esquema del PDF cada vez que se imprime la banda, anidada por nivel de grupo, y las vistas previas muestran el esquema en un panel (ShowOutline). Los elementos también tienen la propiedad Hyperlink, y las bandas y los elementos la propiedad Anchor, ambas plantillas de texto: un enlace web o mailto, o #name para saltar a un ancla. Los enlaces siguen siendo pulsables en la exportación a PDF, etiquetado para PDF/UA y PDF/A-3a, y se conservan en HTML (enlaces e ids de elemento), Word DOCX (hipervínculos y marcadores) y Excel XLSX (hipervínculos de celda), en todas las ediciones. Los elementos también tienen una colección Highlights de estilos condicionales, cada uno con una expresión Condition y un StyleName: cada vez que se imprime el elemento, el primer highlight cuya condición es verdadera sustituye el estilo del elemento, por ejemplo importes negativos en rojo, sin script, en todas las ediciones. El motor también tiene un evento OnProgress con los contadores de páginas y registros y un método Cancel, comprobado entre bandas: las vistas previas muestran el progreso con un botón Cancelar (también Esc), cerrar la ventana cancela un informe largo, y el endpoint HTTP tiene los límites MaxPages y Timeout y responde 503 cuando se cancela un informe, en todas las ediciones. Las expresiones crecen hasta 68 funciones y 10 agregados, en todas las ediciones, Community incluida: aritmética de fechas, relleno y formato, Choose e InList, ToWords para escribir números en letras en los 12 idiomas de sgcUI, SumIf y CountIf, y Previous, RunningSum y RunningCount, que se reinician con cada grupo. Consulta las características de sgcReports y la ayuda de scripts. La exportación a PDF también escribe una factura electrónica: el XML de la factura aportado por la aplicación (Factur-X, ZUGFeRD o XRechnung) se incrusta como archivo asociado PDF/A-3 con los metadatos de Factur-X mediante la nueva propiedad EInvoice, también junto con PDF/A-3a y PDF/UA, en todas las ediciones. sgcReports no crea el XML. Junto con sgcSign, que crea, firma y envía facturas reales, obtiene ambos en un solo archivo.

Las definiciones de informe ahora pueden heredar de una definición base. La base es una plantilla que reúne lo que comparten muchos informes, por ejemplo un membrete, y un hijo la nombra con la nueva propiedad InheritsFrom ("inheritsFrom" en el JSON) y guarda solo lo que es distinto, de modo que un único membrete alimenta facturas, extractos y albaranes. Las páginas, bandas, elementos y estilos se combinan por nombre, y al guardar un hijo solo se escriben las diferencias respecto a la base. Este es el membrete:

{"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."}}

y esta es la factura, que cambia el texto de DocTitle, añade el elemento Number y añade la banda Detail:

{"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"}}

El modelo, las definiciones JSON y la API fluida están en todas las ediciones, Community incluida, y los diseñadores y el endpoint HTTP lo admiten en la edición Registered. Consulte la ayuda sobre la herencia de informes.

Las vistas previas VCL y FireMonkey tienen tres botones nuevos después de Guardar como PDF. Buscar muestra una barra de búsqueda con Anterior y Siguiente, Coincidir mayúsculas y minúsculas y Palabra completa, y resalta todas las coincidencias (Ctrl+F, Enter y F3 funcionan como en un navegador). Miniaturas muestra las páginas como imágenes pequeñas, renderizadas solo cuando se hacen visibles. Exportar abre un menú con PDF, Excel, CSV, PNG, HTML y Word. El evento OnExport se dispara antes de cada exportación, de modo que la aplicación puede establecer las opciones del componente de exportación, cambiar el nombre del archivo o cancelar la exportación. Los botones están en todas las ediciones, incluida Community, y el elemento Word requiere la edición Registered. Este manejador da nombre a la hoja de Excel y cancela la exportación a CSV. Consulte la ayuda de la vista previa.

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;

Los informes aceptan parámetros. Un informe declara parámetros tipados (texto, entero, número, fecha, fecha y hora, sí o no) con valor o expresión predeterminados, valores obligatorios y múltiples, y una lista de valores a partir de una lista estática o de un origen de datos. Las expresiones los leen como :Name, y un origen de conjunto de datos con BindParameters los entrega a los parámetros SQL de su consulta, de modo que la base de datos devuelve solo las filas del rango. Las vistas previas y los diseñadores VCL y FireMonkey piden los valores antes de preparar el informe, el visor HTML muestra un formulario tipado y el endpoint HTTP enlaza ?param.Name=value y responde 400 ante un valor no válido. Los parámetros están en todas las ediciones, Community incluida, y el endpoint HTTP requiere sgcWebSockets Professional o superior. Este informe declara un rango de fechas y una lista de clientes:

{"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"}]}}

El mismo informe servido por HTTP, con la salida del ejemplo compilado. Consulte la ayuda de parámetros de informe.

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

Los informes ahora tienen un elemento de tabla. Tiene columnas, filas de encabezado, datos y pie, celdas combinadas y, para cada celda, un estilo, resaltados y un hipervínculo. Una tabla enlazada a datos tiene su propia fuente de datos e imprime sus filas de datos una vez por registro, con los totales en las filas de pie, y sus filas de encabezado se imprimen de nuevo en cada página o columna nueva. Las exportaciones escriben tablas reales: PDF etiquetado que supera PDF/UA, una tabla HTML, una tabla Word, CSV y una cuadrícula Excel con celdas combinadas. Los diseñadores VCL, FireMonkey, web, WinForms, WPF y Avalonia editan la cuadrícula. Las tablas están en todas las ediciones, incluida Community, y la exportación Word es solo Registered. Esta tabla tiene una fila de encabezado, una fila por registro y una fila de pie con el recuento y el total:

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;

El programa escribe el texto de cada celda, lo que produce esta salida. Consulte la ayuda de tablas.

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

Los informes tienen cuatro tipos de elemento más. Un elemento casilla de verificación se marca con una expresión booleana como Orders.Paid, evaluada para cada registro, con una marca, una cruz o un cuadrado relleno. Se imprime como trazados vectoriales en PDF (una Figure en el PDF/UA etiquetado), como SVG en línea en HTML, como símbolo en DOCX y como valor TRUE o FALSE en XLSX y CSV. Un elemento de imagen ahora imprime imágenes SVG, que siguen siendo vectoriales en PDF y no necesitan ninguna propiedad nueva. Ambos están en todas las ediciones, Community incluida; la edición .NET Community imprime SVG en HTML pero no en PDF. La edición registrada añade un elemento sparkline dibujado por sgcCharts y un elemento indicador dibujado por sgcGauges, como dos puentes que necesitan esos productos. Este informe imprime dos casillas de verificación por pedido, una para los pedidos pagados y una cruz roja para los importes superiores a 100, y guarda las páginas en todos los formatos:

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;

El programa escribe el valor impreso de cada casilla de verificación y después el texto CSV. Vea la ayuda de la casilla de verificación.

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

sgcReports ahora importa informes de otros productos. TsgcReportImporter lee un informe FastReport VCL (.fr3), un formulario QuickReport (.dfm con un TQuickRep) o una plantilla ReportBuilder (.rtm), en texto o binario, y lo convierte en una definición de informe: páginas, bandas, elementos, estilos, campos de datos y expresiones. Nunca falla por lo que no conoce. Cada objeto, propiedad, expresión y script que no pudo asignar se enumera como una incidencia, con la ruta en el informe y el texto original, para que sepa qué corregir. Los diseñadores VCL, FireMonkey, WinForms, WPF y Avalonia tienen un comando Importar, y una demo convierte un archivo. El importador está en la edición registrada. Este código importa un formulario QuickReport, cambia el nombre de su conjunto de datos, imprime las incidencias y guarda la definición JSON:

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;

El programa imprime los recuentos y las incidencias del formulario de ejemplo, lo que da esta salida. El origen de datos, el script y el elemento de texto enriquecido son lo que el importador no pudo trasladar. Consulte la ayuda del importador.

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 para .NET: editar anotaciones y rellenar formularios en WPF y Avalonia

Los visores de WPF y Avalonia hacen ahora lo que hace el visor de WinForms: los usuarios crean, mueven, redimensionan, editan y eliminan anotaciones con el ratón (AnnotationEditing y AnnotationTool), y con FormFilling rellenan campos de texto, casillas de verificación, botones de opción, cuadros combinados y cuadros de lista, con Tab moviéndose por los campos en su orden de tabulación. Consulta las características de sgcPDF.

Accesibilidad comprobada en todas las plataformas

El árbol de UI Automation de cada demo de producto, el árbol que leen lectores de pantalla como Narrator y NVDA, se comprobó con un cliente de UI Automation en VCL, FireMonkey, WinForms, WPF y Avalonia, y se corrigieron los problemas encontrados. Los editores VCL anuncian ahora la etiqueta del campo en lugar de su valor, una barra de navegación plana es una lista en vez de un árbol, las barras de estado de WinForms y WPF ya no toman el foco del teclado, las celdas de la cuadrícula de Avalonia ya no repiten el nombre de su columna, y los puntos de los gráficos y otros elementos dibujados de los controles de Avalonia informan de su posición en pantalla.

Smart tags de Visual Studio y XAML

Los smart tags de los 69 componentes de la caja de herramientas de WinForms se probaron en una superficie de diseño: cada propiedad, editor de colecciones, lista de orígenes de datos, acción y verbo. En WPF y Avalonia, los mosaicos de sgcDashboard y los skins de sgcGauges se declaran en XAML con el mismo prefijo sgc que las columnas, los campos y las series de los demás productos.

sgcEditors: control de diseño y formularios de datos

El nuevo control de diseño, TsgcVCLLayoutControl y TsgcFMXLayoutControl (y los mismos nombres en WinForms, WPF y Avalonia), organiza los controles de un formulario en grupos, grupos con pestañas y columnas, con los títulos alineados a un mismo ancho, divisores que el usuario puede arrastrar y diseños de derecha a izquierda. SaveLayout y LoadLayout guardan como JSON la disposición que hizo el usuario. El control de diseño está en todas las ediciones, Community incluida. Delphi Community no tiene paquete de tiempo de diseño para sgcEditors, así que allí se crea en código.

El formulario de datos se apoya en él. TsgcVCLDataForm y TsgcFMXDataForm generan un formulario de edición completo a partir de un TDataSet, o de las propiedades published de una clase con BindObject, y los formularios de datos de WinForms, WPF y Avalonia aceptan un DataTable, una lista o un objeto. Cada campo recibe un control de sgcEditors, las reglas del validador de sgcUICore y un lugar en un grupo o en una pestaña, y un navegador recorre, añade, edita, elimina y guarda los registros. Smart Paste rellena todo el registro a partir de un texto pegado mediante la capa de IA que los editores ya usan, y marca los campos que rellenó. El formulario de datos está en la edición Registrada, en VCL, FireMonkey, C++Builder, WinForms, WPF y 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;

Consulta las funciones de sgcEditors y la ayuda del formulario de datos.

Paquete HMI de sgcUI: depósitos, P&ID, alarmas y un NumPad

El paquete HMI lleva las pantallas de proceso a sgcUI: paneles de operador, parques de tanques, estaciones de bombeo y otras pantallas de planta. No es un producto nuevo. Cada pieza vive en el producto que amplía y sigue su edición, en VCL y FireMonkey, C++Builder, y WinForms, WPF y Avalonia en .NET. Llama una vez a sgcUIApplyISA101 y todos los controles de sgcUI pasan al esquema gris de ISA-101, donde el color se reserva para los estados anormales y las alarmas.

La aplicación sigue al mando de la planta: trae los valores de sus propios controladores, una base de datos o el puente de indicadores, y decide cuándo se activa una alarma. No hay ningún controlador OPC UA ni Modbus. Los indicadores de depósito y de símbolo de proceso, la lista de alarmas y el NumPad están en todas las ediciones, también en Community, mientras que las plantillas P&ID, los estados de proceso y las tuberías animadas, las fuentes de datos de los indicadores y el registro de reconocimientos de alarmas son de la edición registrada. La demo HMI de la suite reúne las piezas en un pequeño parque de tanques controlado por un simulador. Lee la página del paquete HMI de sgcUI y la ayuda del paquete HMI.

Paquete Realtime UI de sgcUI: presencia, notificaciones, feeds de actividad y registros en vivo

El paquete Realtime UI da a sgcUI las piezas de una pantalla en vivo para Delphi, C++Builder y .NET. No es un producto nuevo. Cada pieza vive en el producto que amplía. sgcUICore añade un modelo de presencia con avatares, un grupo de avatares y un indicador de presencia. sgcNavigation añade un centro de notificaciones con toasts, una bandeja agrupada por día y preferencias por categoría y canal, mientras que TsgcToolbarBadgeLink de sgcToolbar muestra el número de no leídas en un elemento de la barra de herramientas o de la cinta. sgcDashboard añade un feed de actividad y una pista de auditoría, como controles independientes y como mosaicos del panel, y sgcGrid añade un visor de registros en vivo con niveles, filtros, seguimiento del final, pausa y exportación.

Cada modelo recibe un mensaje JSON por cambio. En la edición registrada, las fuentes en vivo WebSocket, MQTT y SSE del puente sgcUICoreWS los alimentan desde sgcWebSockets sin código. Cada control viene con la edición de su producto. Sin servidor, o en una compilación Community, la aplicación actualiza los modelos mediante su API. Lee la página del paquete Realtime UI de sgcUI.

Guías Getting Started para cada producto

Cada producto sgcUI incluye ahora cinco demos QuickStart para Delphi (VCL) y una guía Getting Started, en HTML junto a las demos y en PDF. Las demos van desde el primer formulario hasta una pequeña aplicación completa, y la guía explica cada paso. Empieza con la guía de sgcGrid, la guía de sgcCharts o la guía de sgcChat.

Las 16 guías están listadas en la sección de guías del inicio rápido de sgcUI.

Prueba sgcChat y sgcUI 2026.11

Una prueba para Delphi y otra para C++ Builder instalan los 17 productos de sgcUI.

¿Preguntas o comentarios? Ponte en contacto, te responderán las personas que escribieron el código.