sgcUI 2026.11: sgcChat, assistente de IA e chat de equipe para Delphi, C++ Builder e .NET

· Lançamentos
sgcUI 2026.11: sgcChat, assistente de IA e chat de equipe para Delphi e .NET | Blog eSeGeCe
✦  Nova versão · sgcUI 2026.11

Conheça o sgcChat.
Um chat dentro da sua aplicação.

Um assistente de IA que transmite as respostas em Markdown formatado e um chat de equipe com presença, digitação, confirmações de leitura e reações. Controles nativos para Delphi, C++ Builder e .NET.

Também no YouTube.

  • VCL
  • FireMonkey
  • WinForms
  • WPF
  • Avalonia
  • SVG e PNG sem janela
Uma conversa com um assistente de IA e um chat de equipe lado a lado, desenhados pelo sgcChat
17produtos sgcUI
4controles de chat
5frameworks de interface
12idiomas

Hoje lançamos o sgcUI 2026.11. Ele traz dois novos produtos: o sgcChat, que coloca um chat com assistente de IA e um chat de equipe dentro da sua própria aplicação, e o sgcSpreadsheet, uma planilha estilo Excel. Ele também preenche uma lista de lacunas menores na suíte: medidores que recebem entrada do usuário, vinculação de dados que acompanha o dataset nos dois sentidos, um dashboard publicado como página web, séries recorrentes do Outlook no planejador, scripts em relatórios e mais.

O sgcChat é o décimo sexto produto do sgcUI. Ele roda em VCL e FireMonkey para Delphi e C++ Builder, e em WinForms, WPF e Avalonia para .NET, e está incluído no sgcUI Enterprise e no All-Access. Ele não é vendido como pacote separado.

sgcChat: um assistente de IA na sua aplicação

Uma resposta de IA chega em pequenos pedaços, e os usuários esperam lê-la enquanto ela é escrita. O TsgcChatAI vincula uma conversa a um provedor, envia o histórico e o prompt de sistema e mostra cada pedaço como Markdown formatado assim que ele chega. O provedor roda em uma thread de trabalho, de modo que a janela continua responsiva, e o painel de chat oferece parar, gerar novamente e editar e reenviar para cada resposta.

Uma conversa com um assistente de IA no painel do sgcChat
O assistente de IA no painel de chat.

O sgcChat não prende você a um único fornecedor de IA. O TsgcChatAIProvider_AIChat conecta-se ao TsgcAIChat do sgcWebSockets, que fala com OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok e Mistral. O TsgcChatAIProvider_UICore usa a camada de provedores de IA que todos os produtos sgcUI compartilham, e o TsgcChatAIEventProvider permite transmitir do seu próprio backend em um evento. É assim que uma vinculação TsgcChatAI responde com a 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;

Altere Provider para usar Anthropic, Gemini, DeepSeek, Ollama, Grok ou Mistral. A ajuda do sgcChat tem o guia de início rápido completo.

A conversa com Claude, OpenAI, Gemini e os demais provedores de LLM exige o sgcWebSockets, que está incluído no All-Access. O TsgcChatAIProvider_AIChat está no pacote de ponte sgcChatWS (.NET: esegece.sgcChat.sgcWebSockets). Sem o sgcWebSockets, o TsgcChatAIEventProvider permite que o seu próprio código chame qualquer serviço de IA.

sgcChat: um chat de equipe no seu próprio servidor

Centrais de suporte, equipes de campo e ferramentas internas precisam de um chat que os usuários já saibam usar. A visualização do chat agrupa as mensagens de cada autor com um avatar e um nome, mostra quem está online, ausente ou ocupado, mostra quem está digitando e marca cada mensagem como enviada, entregue ou lida. Os usuários respondem a uma mensagem, reagem a ela, editam ou excluem as próprias mensagens e enviam anexos com miniaturas de imagens e chips de arquivo.

Um chat de equipe com avatares, presença e confirmações de leitura no sgcChat
Um chat de equipe com presença, digitação e confirmações de leitura.

O chat não depende de um único servidor. O TsgcChatEventTransport entrega ao seu código cada mensagem, mudança de digitação, confirmação e reação como um frame JSON documentado. Com o sgcWebSockets, o TsgcChatTransport_WebSocket conecta um cliente e o TsgcChatServer_WebSocket repassa as mensagens entre os clientes de um canal, mantém a presença de cada usuário e envia as últimas mensagens aos usuários que entram depois. O relay roda em um serviço ou em um programa de console:

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;

Os dois exemplos em Delphi acima foram copiados sem alterações dos exemplos da ajuda do sgcChat, que foram compilados com o Delphi 13 (Win32) contra os fontes do sgcUI e do sgcWebSockets.

O chat de equipe por WebSocket exige o sgcWebSockets, que está incluído no All-Access. O TsgcChatTransport_WebSocket e o TsgcChatServer_WebSocket estão no pacote de ponte sgcChatWS (.NET: esegece.sgcChat.sgcWebSockets). Sem o sgcWebSockets, o TsgcChatEventTransport conecta o chat a qualquer backend.

sgcChat: um visualizador Markdown nativo

O motor por trás dos balões do chat também é um controle independente. O TsgcVCLMarkdownViewer e o TsgcFMXMarkdownViewer mostram títulos, ênfase, citações, listas, listas de tarefas, tabelas, links e imagens, e destacam a sintaxe dos blocos de código em Pascal, C#, C++, JavaScript, Python, JSON, SQL e outras linguagens. O AppendMarkdown adiciona texto conforme ele chega, e os usuários selecionam e copiam o texto ou um bloco de código inteiro com o botão de copiar. Use-o para notas de versão, páginas de ajuda e mensagens escritas em Markdown.

O visualizador Markdown do sgcChat no tema claro
Visualizador Markdown, claro
O visualizador Markdown do sgcChat no tema escuro
Visualizador Markdown, escuro

O sgcChat se integra ao resto da suíte

O chat segue os temas claro, escuro e Fluent do sgcUI. Uma conversa em árabe ou hebraico é espelhada, e os textos dos controles estão traduzidos para os 12 idiomas do sgcUI. No Windows, a visualização do chat é uma lista de mensagens para leitores de tela, com o autor e a hora de cada mensagem. O modelo da conversa, o documento Markdown e a visualização não dependem de VCL nem de FireMonkey, de modo que um serviço pode renderizar uma conversa ou um documento Markdown em SVG ou PNG sem janela, inclusive no Linux64.

Os componentes são TsgcVCLChatPanel, TsgcVCLChatView, TsgcVCLChatInput e TsgcVCLMarkdownViewer, o mesmo conjunto com o prefixo TsgcFMX para FireMonkey, e os mesmos controles para WinForms, WPF e Avalonia, como TsgcWinFormsChatPanel, TsgcWpfChatPanel e TsgcAvaloniaChatPanel. As demonstrações cobrem um assistente de IA, um cliente de chat de equipe com o seu servidor relay e o visualizador Markdown, para VCL, FireMonkey, C++ Builder, WinForms, WPF e Avalonia.

O sgcChat é vendido como parte do sgcUI Enterprise e do pacote All-Access, que também inclui o sgcWebSockets para o provedor de IA e a ponte WebSocket. Veja a página do sgcChat e a matriz de recursos.

sgcSpreadsheet: uma planilha estilo Excel

O sgcSpreadsheet é o décimo sétimo produto do sgcUI. É um controle de planilha construído sobre o sgcGrid e um motor de fórmulas compartilhado por meio do sgcUICore: TsgcVCLSpreadsheet para VCL, TsgcFMXSpreadsheet para FireMonkey, uma barra de fórmulas para cada um, e TsgcWinFormsSpreadsheet, TsgcWpfSpreadsheet e TsgcAvaloniaSpreadsheet para .NET.

Ele avalia 211 funções de planilha, de matemática, estatística, texto e datas a pesquisas com XLOOKUP e matrizes dinâmicas como SEQUENCE, SORT, FILTER e UNIQUE. Um grafo de dependências recalcula apenas as células que mudam, as matrizes dinâmicas se expandem para as células ao lado, e as planilhas suportam nomes definidos, várias planilhas, painéis congelados e funções personalizadas registradas pelo seu aplicativo. Os gráficos são criados a partir de intervalos de células em 7 tipos de gráfico desenhados com o sgcCharts, e a pasta de trabalho carrega e grava arquivos XLSX, gráficos incluídos.

O sgcSpreadsheet está incluído no sgcUI Enterprise e no pacote All-Access, e também é vendido como pacote individual para Delphi e para .NET. A instalação dele instala o sgcGrid e o sgcCharts. Veja a página do sgcSpreadsheet e a lista de recursos.

Em toda a suíte: entrada, dados e saída

O restante da versão preenche lacunas menores nos produtos: controles que recebem entrada do usuário, vinculação de dados que acompanha o dataset nos dois sentidos e mais formas de tirar uma tela da aplicação.

sgcGauges: medidores de entrada e skins

Quatro medidores de entrada, TsgcVCLKnobGauge, TsgcVCLSliderGauge, TsgcVCLToggleSwitchGauge e TsgcVCLPushButtonGauge (TsgcFMX no FireMonkey, e os mesmos nomes em WinForms, WPF e Avalonia), permitem que o usuário defina um valor com o mouse, o toque, a roda ou o teclado. O OnUserChange dispara apenas para alterações feitas pelo usuário, e os leitores de tela os veem como um controle deslizante, um interruptor e um botão. O sgcGauges agora tem dezesseis tipos de medidor, contando os medidores de tanque e de símbolo de processo do pacote HMI abaixo.

O Skin dá a cada medidor uma nova aparência: Classic, Modern, Industrial, ISA101, Dark ou um skin próprio registrado com sgcGaugesRegisterSkin. O TsgcGaugeDataLink mostra um campo de dataset em qualquer medidor e grava de volta no campo as alterações de um medidor de entrada. Veja os recursos do sgcGauges e a ajuda dos medidores de entrada.

Vinculação de dados ao vivo e nos dois sentidos

Os produtos acompanham um TDataSet do Delphi, ou um DataTable no .NET, enquanto ele muda, e os produtos de edição gravam de volta as alterações do usuário:

sgcDiagram, sgcPivotGrid, sgcGauges e sgcDashboard têm a mesma vinculação no .NET. A matriz de recursos do sgcUI lista o que cada edição inclui.

sgcPlanner: séries do Outlook, lembretes do Google e capacidade

O TsgcPlannerGraphSync agora traz as séries recorrentes do Outlook como um único item recorrente com o seu RRULE, as ocorrências alteradas como ocorrências modificadas e as canceladas como exceções, e envia de volta ao Outlook as séries criadas no planejador. O TsgcPlannerGoogleSync envia ao Google Calendar os lembretes alterados no planejador quando um evento é atualizado e lê de volta os alterados no Google. Uma Capacity por recurso (1 para uma pessoa em tempo integral, 0.5 para meio período, 3 para uma equipe de três) controla a linha de capacidade do histograma de carga, e é lida e gravada como MaxUnits no Microsoft Project XML. Veja os recursos do sgcPlanner.

sgcDashboard: publicar na web e o tile de mapa em todo lugar

O SaveToHTML grava um dashboard como uma única página HTML autocontida. Cada tile é desenhado como SVG pelo mesmo código que o imprime, em uma grade CSS que segue os breakpoints do dashboard, e todo tile tem um título e uma alternativa em texto para leitores de tela. Sem uma URL de atualização, a página não tem nenhum script. No .NET, o tile de mapa agora existe também para WPF e Avalonia, e os mapas aparecem na impressão, no PDF e na saída HTML do dashboard. Leia a ajuda de publicar na web e os recursos do sgcDashboard.

sgcMaps: desenhe o mapa em qualquer canvas

O DrawTo no TsgcVCLMap, no TsgcFMXMap e no SgcMapControl do WinForms desenha a vista atual, com os tiles carregados, em um retângulo de qualquer canvas do sgcUI, e os mapas de WPF e Avalonia também renderizam em qualquer canvas do sgcUI. É assim que um mapa em um tile de dashboard chega à impressão, ao PDF e à página HTML. Veja os recursos do sgcMaps.

sgcWizard: transições e uma página de resumo

O Transition anima a troca de página com um deslize, um fade ou ambos, espelhado em layouts da direita para a esquerda, e o ReduceMotion segue a configuração de animação do Windows. Com ShowSummary, o assistente adiciona uma última página que lista os campos e os valores que o usuário informou em cada página visitada, com as senhas mascaradas e um link Editar que volta para cada página. Veja os recursos do sgcWizard e a ajuda da página de resumo.

sgcReports: scripts e a visualização do FireMonkey em todas as plataformas

O TsgcReport.Script guarda procedimentos em uma pequena linguagem parecida com Pascal, armazenada na definição do relatório e no JSON. O relatório executa um script quando começa e quando termina, e cada banda e cada item antes e depois de imprimir, de modo que um script pode ocultar uma banda ou mudar o texto, a cor da fonte ou a altura de um item na impressão atual. Os designers de VCL, FireMonkey, WinForms, WPF e Avalonia editam o script com um botão Check que mostra a linha e a coluna de um erro. A visualização do FireMonkey roda em Windows, macOS, iOS e Android, com pan por toque e zoom por pinça, e no iOS e no Android, Imprimir e Salvar PDF abrem a planilha de compartilhamento do sistema. As bandas e os itens também têm a propriedade Bookmark, um modelo de texto que adiciona uma entrada à estrutura de tópicos do PDF cada vez que a banda é impressa, aninhada por nível de grupo, e as pré-visualizações mostram essa estrutura em um painel (ShowOutline). Os itens também têm a propriedade Hyperlink, e as bandas e os itens a propriedade Anchor, ambas modelos de texto: um link web ou mailto, ou #name para saltar a uma âncora. Os links permanecem clicáveis na exportação para PDF, com marcação para PDF/UA e PDF/A-3a, e são mantidos no HTML (links e ids de elemento), no Word DOCX (hiperlinks e marcadores) e no Excel XLSX (hiperlinks de célula), em todas as edições. Os itens também têm uma coleção Highlights de estilos condicionais, cada um com uma expressão Condition e um StyleName: a cada impressão do item, o primeiro highlight cuja condição for verdadeira substitui o estilo do item, por exemplo valores negativos em vermelho, sem script, em todas as edições. O motor também tem um evento OnProgress com os contadores de páginas e registros e um método Cancel, verificado entre as bandas: as visualizações mostram o progresso com um botão Cancelar (também Esc), fechar a janela cancela um relatório longo, e o endpoint HTTP tem os limites MaxPages e Timeout e responde 503 quando um relatório é cancelado, em todas as edições. As expressões passam a ter 68 funções e 10 agregados, em todas as edições, inclusive a Community: aritmética de datas, preenchimento e formatação, Choose e InList, ToWords para escrever números por extenso nos 12 idiomas do sgcUI, SumIf e CountIf, e Previous, RunningSum e RunningCount, que reiniciam a cada grupo. Veja os recursos do sgcReports e a ajuda de scripts. A exportação para PDF também grava uma fatura eletrônica: o XML da fatura fornecido pelo aplicativo (Factur-X, ZUGFeRD ou XRechnung) é incorporado como arquivo associado PDF/A-3 com os metadados do Factur-X por meio da nova propriedade EInvoice, também junto com PDF/A-3a e PDF/UA, em todas as edições. O sgcReports não cria o XML. Junto com sgcSign, que cria, assina e envia faturas reais, você obtém os dois em um único arquivo.

As definições de relatório agora podem herdar de uma definição base. A base é um modelo que reúne o que muitos relatórios compartilham, por exemplo um papel timbrado, e um filho a nomeia com a nova propriedade InheritsFrom ("inheritsFrom" no JSON) e guarda apenas o que é diferente, de modo que um único papel timbrado alimenta faturas, extratos e guias de remessa. Páginas, bandas, itens e estilos são mesclados pelo nome, e ao salvar um filho só as diferenças em relação à base são gravadas. Este é o papel timbrado:

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

e esta é a fatura, que altera o texto de DocTitle, adiciona o item Number e adiciona a 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"}}

O modelo, as definições JSON e a API fluente estão em todas as edições, inclusive na Community, e os designers e o endpoint HTTP oferecem suporte na edição Registered. Veja a ajuda sobre herança de relatórios.

As visualizações VCL e FireMonkey têm três botões novos depois de Salvar como PDF. Localizar mostra uma barra de busca com Anterior e Próximo, Diferenciar maiúsculas e minúsculas e Palavra inteira, e destaca todas as ocorrências (Ctrl+F, Enter e F3 funcionam como em um navegador). Miniaturas mostra as páginas como imagens pequenas, renderizadas somente quando ficam visíveis. Exportar abre um menu com PDF, Excel, CSV, PNG, HTML e Word. O evento OnExport é disparado antes de cada exportação, de modo que a aplicação pode definir as opções do componente de exportação, alterar o nome do arquivo ou cancelar a exportação. Os botões estão em todas as edições, inclusive Community, e o item Word exige a edição Registered. Este manipulador dá nome à planilha do Excel e cancela a exportação para CSV. Veja a ajuda da visualização.

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;

Os relatórios aceitam parâmetros. Um relatório declara parâmetros tipados (texto, inteiro, número, data, data e hora, sim ou não) com valor ou expressão padrão, valores obrigatórios e múltiplos, e uma lista de valores a partir de uma lista estática ou de uma fonte de dados. As expressões os leem como :Name, e uma fonte de conjunto de dados com BindParameters os entrega aos parâmetros SQL da sua consulta, de modo que o banco de dados devolve apenas as linhas do intervalo. As pré-visualizações e os designers VCL e FireMonkey pedem os valores antes de o relatório ser preparado, o visualizador HTML mostra um formulário tipado e o endpoint HTTP associa ?param.Name=value e responde 400 para um valor inválido. Os parâmetros estão em todas as edições, inclusive Community, e o endpoint HTTP exige sgcWebSockets Professional ou superior. Este relatório declara um intervalo de datas e uma 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"}]}}

O mesmo relatório servido por HTTP, com a saída do exemplo compilado. Veja a ajuda de parâmetros de relatório.

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

Os relatórios agora têm um item de tabela. Ele tem colunas, linhas de cabeçalho, dados e rodapé, células mescladas e, para cada célula, estilo, destaques e hiperlink. Uma tabela ligada a dados tem fonte de dados própria e imprime suas linhas de dados uma vez por registro, com os totais nas linhas de rodapé, e as linhas de cabeçalho são impressas de novo em cada nova página ou coluna. As exportações gravam tabelas reais: PDF marcado que passa no PDF/UA, uma tabela HTML, uma tabela Word, CSV e uma grade Excel com células mescladas. Os designers VCL, FireMonkey, web, WinForms, WPF e Avalonia editam a grade. As tabelas estão em todas as edições, inclusive Community, e a exportação Word é somente Registered. Esta tabela tem uma linha de cabeçalho, uma linha por registro e uma linha de rodapé com a contagem e o 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;

O programa escreve o texto de cada célula, o que produz esta saída. Veja a ajuda de tabelas.

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

Os relatórios têm mais quatro tipos de item. Um item de caixa de seleção é marcado por uma expressão booleana como Orders.Paid, avaliada para cada registro, com uma marca de seleção, uma cruz ou um quadrado preenchido. Ele é impresso como caminhos vetoriais no PDF (uma Figure no PDF/UA com tags), como SVG embutido no HTML, como símbolo no DOCX e como valor TRUE ou FALSE em XLSX e CSV. Um item de imagem agora imprime imagens SVG, que continuam vetoriais no PDF e não precisam de nenhuma propriedade nova. Ambos estão em todas as edições, inclusive a Community; a edição .NET Community imprime SVG no HTML, mas não no PDF. A edição registrada adiciona um item sparkline desenhado pelo sgcCharts e um item gauge desenhado pelo sgcGauges, como duas pontes que precisam desses produtos. Este relatório imprime duas caixas de seleção por pedido, uma para os pedidos pagos e uma cruz vermelha para os valores acima de 100, e salva as páginas em todos os 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;

O programa grava o valor impresso de cada caixa de seleção e, em seguida, o texto CSV. Veja a ajuda da caixa de seleção.

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

O sgcReports agora importa relatórios de outros produtos. TsgcReportImporter lê um relatório FastReport VCL (.fr3), um formulário QuickReport (.dfm com um TQuickRep) ou um modelo ReportBuilder (.rtm), em texto ou binário, e o converte em uma definição de relatório: páginas, bandas, itens, estilos, campos de dados e expressões. Ele nunca falha com o que não conhece. Cada objeto, propriedade, expressão e script que não conseguiu mapear é listado como um problema, com o caminho no relatório e o texto original, para que você saiba o que corrigir. Os designers VCL, FireMonkey, WinForms, WPF e Avalonia têm um comando Importar, e há uma demo que converte um arquivo. O importador está na edição registrada. Este código importa um formulário QuickReport, renomeia seu conjunto de dados, imprime os problemas e salva a definição 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;

O programa imprime as contagens e os problemas do formulário de exemplo, o que produz esta saída. A fonte de dados, o script e o item de rich text são o que o importador não conseguiu aproveitar. Veja a ajuda do 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 anotações e preencher formulários no WPF e no Avalonia

Os visualizadores de WPF e Avalonia agora fazem o que o visualizador do WinForms faz: os usuários criam, movem, redimensionam, editam e excluem anotações com o mouse (AnnotationEditing e AnnotationTool) e, com FormFilling, preenchem campos de texto, caixas de seleção, botões de opção, caixas de combinação e caixas de listagem, com a tecla Tab percorrendo os campos na ordem de tabulação. Veja os recursos do sgcPDF.

Acessibilidade verificada em todas as plataformas

A árvore UI Automation de cada demonstração de produto, a árvore que os leitores de tela como o Narrator e o NVDA leem, foi verificada com um cliente UI Automation em VCL, FireMonkey, WinForms, WPF e Avalonia, e os problemas encontrados foram corrigidos. Os editores VCL agora anunciam o rótulo do campo em vez do seu valor, uma barra de navegação plana é uma lista e não uma árvore, as barras de status de WinForms e WPF não recebem mais o foco do teclado, as células do grid Avalonia não repetem mais o nome da coluna e os pontos de gráfico e outros itens desenhados dos controles Avalonia informam a sua posição na tela.

Smart tags do Visual Studio e XAML

As smart tags de todos os 69 componentes WinForms da toolbox foram testadas em uma superfície de design: cada propriedade, editor de coleção, lista de fontes de dados, ação e verbo. No WPF e no Avalonia, os tiles do sgcDashboard e os skins do sgcGauges são declarados em XAML sob o mesmo prefixo sgc das colunas, campos e séries dos outros produtos.

sgcEditors: controle de layout e formulários de dados

O novo controle de layout, TsgcVCLLayoutControl e TsgcFMXLayoutControl (e os mesmos nomes no WinForms, WPF e Avalonia), organiza os controles de um formulário em grupos, grupos com abas e colunas, com os rótulos alinhados a uma só largura, divisores que o usuário pode arrastar e layouts da direita para a esquerda. SaveLayout e LoadLayout guardam como JSON a disposição feita pelo usuário. O controle de layout está em todas as edições, inclusive na Community. O Delphi Community não tem pacote de design para o sgcEditors, então nele é criado em código.

O formulário de dados é construído sobre ele. TsgcVCLDataForm e TsgcFMXDataForm geram um formulário de edição completo a partir de um TDataSet, ou das propriedades published de uma classe com BindObject, e os formulários de dados do WinForms, WPF e Avalonia aceitam um DataTable, uma lista ou um objeto. Cada campo recebe um controle do sgcEditors, as regras do validador do sgcUICore e um lugar em um grupo ou em uma aba, e um navegador percorre, inclui, edita, exclui e grava os registros. O Smart Paste preenche o registro inteiro a partir de um texto colado, pela camada de IA que os editores já usam, e marca os campos que preencheu. O formulário de dados está na edição Registrada, no VCL, FireMonkey, C++Builder, WinForms, WPF e 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;

Veja os recursos do sgcEditors e a ajuda do formulário de dados.

Pacote HMI do sgcUI: tanques, P&ID, alarmes e um NumPad

O pacote HMI traz telas de processo ao sgcUI: painéis de operador, parques de tanques, estações de bombeamento e outros displays de planta. Não é um produto novo. Cada peça fica no produto que ela estende e segue a sua edição, em VCL e FireMonkey, C++Builder, e WinForms, WPF e Avalonia no .NET. Chame sgcUIApplyISA101 uma vez e todo controle sgcUI passa para o esquema cinza ISA-101, em que a cor é reservada para estados anormais e alarmes.

A aplicação continua no comando da planta: ela traz os valores dos seus próprios drivers, de um banco de dados ou da ponte dos medidores, e decide quando um alarme é disparado. Não há driver OPC UA ou Modbus. Os medidores de tanque e de símbolo de processo, a lista de alarmes e o NumPad estão em todas as edições, inclusive a Community, enquanto os stencils P&ID, os estados de processo e as tubulações animadas, os feeds dos medidores e o log de reconhecimento de alarmes são da edição Registrada. A demo HMI da suíte reúne as peças em um pequeno parque de tanques controlado por um simulador. Leia a página do Pacote HMI do sgcUI e a ajuda do pacote HMI.

Pacote Realtime UI do sgcUI: presença, notificações, feeds de atividades e logs ao vivo

O pacote Realtime UI dá ao sgcUI as peças de uma tela ao vivo para Delphi, C++Builder e .NET. Ele não é um produto novo. Cada peça vive no produto que ela estende. O sgcUICore adiciona um modelo de presença com avatares, um grupo de avatares e um indicador de presença. O sgcNavigation adiciona uma central de notificações com toasts, uma caixa de entrada agrupada por dia e preferências por categoria e canal, enquanto o TsgcToolbarBadgeLink do sgcToolbar mostra o número de não lidas em um item da barra de ferramentas ou do ribbon. O sgcDashboard adiciona um feed de atividades e uma trilha de auditoria, como controles independentes e como blocos do painel, e o sgcGrid adiciona um visualizador de log ao vivo com níveis, filtros, acompanhamento do final, pausa e exportação.

Cada modelo recebe uma mensagem JSON por alteração. Na edição Registrada, as fontes ao vivo WebSocket, MQTT e SSE da ponte sgcUICoreWS os alimentam a partir do sgcWebSockets sem código. Cada controle vem com a edição do seu produto. Sem um servidor, ou em um build Community, a aplicação atualiza os modelos pela API deles. Leia a página do pacote Realtime UI do sgcUI.

Guias Primeiros Passos para todos os produtos

Todo produto sgcUI agora inclui cinco demos QuickStart para Delphi (VCL) e um guia Primeiros Passos, em HTML junto às demos e em PDF. As demos vão do primeiro formulário até uma pequena aplicação completa, e o guia explica cada etapa. Comece pelo guia do sgcGrid, pelo guia do sgcCharts ou pelo guia do sgcChat.

Os 16 guias estão listados na seção de guias do início rápido do sgcUI.

Experimente o sgcChat e o sgcUI 2026.11

Uma versão de teste para Delphi e uma para C++ Builder instalam os 17 produtos sgcUI.

Dúvidas ou comentários? Entre em contato, você receberá a resposta das pessoas que escreveram o código.