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.
- VCL
- FireMonkey
- WinForms
- WPF
- Avalonia
- SVG e PNG sem janela
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.
- Markdown em streaming com um cursor enquanto a resposta é escrita.
- Cartões de chamada de ferramenta com o nome da ferramenta, os argumentos, o resultado e um estado de em execução, concluído ou erro.
- O histórico da conversa salvo em JSON e carregado dele.
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.
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 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:
- sgcPlanner: o
TsgcPlannerSource_DataSetinforma cada gravação comOnWriteBack, pode recusar uma emOnBeforeWriteBacke devolve o planejador aos dados quando uma gravação é recusada ou falha. OThrottleagrupa alterações rápidas e oFollowCursorseleciona o item do registro atual. - sgcDiagram: o
TsgcDiagramDataBindingacompanha os datasets de nós e links por Id, armazena a posição e o tamanho dos nós e, comWriteBack, grava de volta nos dados os nós e links que os usuários adicionam, movem, editam ou excluem. - sgcPivotGrid e sgcDashboard: a fonte DataSet do pivot e a fonte de dados do dashboard acompanham um dataset com um
Throttleque agrupa alterações rápidas em uma única atualização.
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.
- sgcGauges: um medidor de tanque e de vaso,
TsgcVCLTankGauge, em quatro formatos com limites HH, H, L e LL e histerese, e um medidor de símbolo de processo,TsgcVCLSymbolGauge, que desenha uma válvula, bomba, motor, ventilador, trocador de calor ou sensor como desligado, ligado, falha, aberto, fechado ou em trânsito, com bombas e ventiladores que giram enquanto funcionam. A ponte sgcGaugesWS alimenta ambos a partir de MQTT, WebSocket ou SSE, e oValueMaptransforma códigos da planta, comoRUNNING, em estados do símbolo. - sgcDiagram: 56 stencils P&ID no estilo da ISA-5.1 para bombas, válvulas, vasos, equipamentos de troca de calor, tubulações e instrumentos, e estados de processo e tubulações animadas por meio das regras do
TsgcDiagramStatusBinding. - sgcGrid: uma lista de alarmes ISA-18.2. O
TsgcGridAlarmModelguarda os alarmes com prioridades de 1 a 4 e seis estados, com Acknowledge, Shelve, filtros e exportação para JSON e CSV. OTsgcGridAlarmLinkos exibe em uma grade com cores de prioridade e linhas piscantes, e o menu de alarmes dá ao operador os comandos. - sgcEditors: o
TsgcVCLNumPad, um NumPad para painéis touch, fixado no formulário ou como lista suspensa, que digita nos spin edits e edits de moeda, em um edit padrão e nos medidores de botão giratório e de controle deslizante.
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.
