Generador de informes para Delphi: diseña informes de forma visual o en código

sgcReports es un generador de informes para Delphi y C++ Builder: tus usuarios diseñan informes de forma visual, y tu código los construye con la clase fluida TsgcReportBuilder.

Diseñadores VCL, FireMonkey y web
Informes construidos en código
Bandas, grupos y maestro detalle
Exportación a PDF, Excel y CSV

Ver precios →

Vista previa de un informe de Delphi con un informe terminado de ventas por región y mes, cuadros KPI y un gráfico apilado de ingresos, botones Export PDF y Export XLSX, creado con sgcReports en la demo Altamira ERP

Dos formas de crear un informe en Delphi

Un informe es un modelo de páginas, bandas, elementos, estilos y fuentes de datos. El diseñador y el código editan ese modelo, y una definición JSON lo almacena.

Tus usuarios diseñan informes de forma visual en el diseñador de informes VCL, FireMonkey o web, y tu código los construye con la clase fluida TsgcReportBuilder. Ambos producen el mismo modelo de informe, con bandas, grupos, maestro detalle y expresiones, que puedes previsualizar, imprimir o exportar a PDF, Excel, CSV y más, en el escritorio o en un servicio sin ventana.

Diseñador visual de informes

Coloca un TsgcVCLReportDesigner o un TsgcFMXReportDesigner en un formulario, o sirve TsgcReportHTMLDesigner en el navegador. Los usuarios arrastran campos a las bandas, establecen propiedades en un inspector y cambian a una vista previa en vivo. Registered

Diseña informes de forma visual →

Informes como código

TsgcReportBuilder describe estilos, páginas, bandas y elementos como una única cadena fluida. El informe se compila, se compara y se refactoriza junto con el resto de tu proyecto, y funciona desde Delphi 7, sin necesidad de métodos anónimos.

Crea informes en código →

Definiciones JSON

Guarda un informe con sgcReportSaveToJSONFile y cárgalo en tiempo de ejecución, de modo que un diseño pueda vivir en una base de datos o en una carpeta de cliente y cambiar sin una nueva compilación. Los diseñadores abren y guardan los mismos archivos.

Sobre las definiciones JSON →

Diseña informes de forma visual en VCL, FireMonkey y el navegador

Un diseñador de informes para usuarios finales que ellos ejecutan dentro de tu aplicación, y el mismo diseñador en tiempo de diseño en el IDE.

El diseñador de informes VCL de sgcReports con un albarán abierto, el esquema de bandas, la superficie de diseño y el inspector de propiedades

Diseñador de informes solo Registered

Un diseñador de informes que tus usuarios pueden ejecutar

TsgcVCLReportDesigner es un panel con una barra de herramientas, las pestañas Toolbox, Outline y Data, una superficie de diseño con reglas, un inspector de propiedades y pestañas Design y Preview. Colócalo en un formulario, asigna Engine, añade las fuentes de datos, y tus usuarios editan el informe, lo guardan como definición JSON y lo previsualizan con datos en vivo. TsgcFMXReportDesigner es su gemelo de FireMonkey, construido sobre las mismas unidades del diseñador.

  • Barra de herramientas con New, Open, Import, Save, Undo, Redo, alineación, distribución y zoom
  • Arrastra un elemento del Toolbox o un campo del árbol Data a una banda: texto, texto enriquecido, imagen, línea, forma, código de barras, subinforme, salto de página, tabla de referencias cruzadas y tabla
  • Editores para los parámetros del informe, las tablas y el script del informe
  • La pestaña Preview prepara el informe con los datos del motor
  • En tiempo de diseño, haz clic derecho en un TsgcReportEngine en el IDE y elige Design report… para editar su informe con el mismo diseñador
Lee el tema de ayuda

Conecta el diseñador al motor y a las fuentes de datos cuando se cree el formulario, y carga el último diseño guardado:

procedure TfrmMain.FormCreate(Sender: TObject);
begin
  sgcDesigner.Engine := sgcEngine;
  sgcDesigner.AddDataSource(sgcOrders);
  if FileExists('orders.json') then
    sgcDesigner.LoadFromFile('orders.json')
  else
    sgcDesigner.NewReport;
end;

procedure TfrmMain.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
  if sgcDesigner.Modified then
    sgcDesigner.SaveToFile('orders.json');
end;

Para editar un informe desde un menú sin un formulario dedicado, sgcShowReportDesigner (VCL) o sgcShowReportDesignerFMX (FireMonkey, Windows y macOS) muestra el diseñador de forma modal con botones OK y Cancel, y restaura el informe cuando el usuario cancela:

procedure TfrmMain.mnuEditReportClick(Sender: TObject);
begin
  if sgcShowReportDesigner(sgcEngine) then
    sgcReportSaveToJSONFile(sgcEngine.Report, 'orders.json');
end;

Diseñador FireMonkey

TsgcFMXReportDesigner (Delphi XE6 y posteriores) tiene la misma barra de herramientas, árboles, superficie, inspector y pestaña de vista previa, y aloja un TsgcReportPreviewFMX. ToolbarButtonSize hace que los botones sean fáciles de pulsar en una pantalla táctil. El formulario modal y los diálogos de archivo están disponibles en Windows y macOS.

Diseñador de informes web

TsgcReportHTMLDesigner edita la definición JSON en el navegador con un lienzo de bandas, un inspector de propiedades y una vista previa en vivo, servido por el mismo endpoint HTTP que el informe terminado. Necesita sgcWebSockets Professional o superior y sgcHTML. Deja DesignerEnabled desactivado en los endpoints de producción y colócalo detrás de tu propia autenticación.

Sobre el diseñador web →

Diseñadores .NET

sgcReports para .NET incluye diseñadores para usuarios finales para WinForms, WPF y Avalonia, los equivalentes de TsgcVCLReportDesigner, con la misma barra de herramientas, árboles, inspector y vista previa. También cargan y guardan definiciones JSON.

Crea informes en código con TsgcReportBuilder

Un informe de ventas agrupado sobre cualquier TDataSet: una cabecera por región, una línea por venta, un subtotal por región y un pie de página, guardado como PDF y Excel.

uses
  Classes, SysUtils, DB,
  sgcReports_Types, sgcReports_Model, sgcReports_Data, sgcReports_Fluent;

const
  CS_TOTAL = '[FormatFloat(''#,0.00'', Sum(Sales.Amount))]';

procedure ExportSalesReport(aSales: TDataSet; const aFolder: string);
var
  oSales: TsgcReportDataSetSource;
  oBuilder: TsgcReportBuilder;
begin
  oSales := TsgcReportDataSetSource.Create(nil);
  oBuilder := TsgcReportBuilder.Create;
  try
    // any TDataSet: FireDAC, TClientDataSet, dbExpress...
    oSales.SourceName := 'Sales';
    oSales.DataSet := aSales;
    oBuilder.Title('Sales by region').Units(ruMillimeters)
      .Style('Base').Font('Arial', 10).EndStyle
      .Style('Group').Font('Arial', 11).Bold.BackColor($EEEEEE).EndStyle
      .Page.Paper(rpsA4).Margins(15)
      .GroupHeader('Sales.Region', 9).Style('Group')
      .Text('Region: [Sales.Region]', 0, 1, 180, 7).TagRole(rtrHeading2).EndBand
      .MasterData('Sales', 6).Style('Base')
      .Text('[Sales.Customer]', 2, 0, 120, 6)
      .Text('[Sales.Amount]', 130, 0, 50, 6).AlignRight.Format('#,0.00').EndBand
      .GroupFooter(9).Style('Base')
      .Text('Region total ' + CS_TOTAL, 80, 1, 100, 6).AlignRight.Bold.EndBand
      .PageFooter(8).Style('Base')
      .Text('Page [Page] of [TotalPages]', 0, 1, 180, 6).AlignCenter.EndBand
      .EndPage.Data(oSales);
    oBuilder.SaveToPDF(IncludeTrailingPathDelimiter(aFolder) + 'sales.pdf');
    oBuilder.SaveToXLSX(IncludeTrailingPathDelimiter(aFolder) + 'sales.xlsx');
  finally
    oBuilder.Free;
    oSales.Free;
  end;
end;

Lee el tema de ayuda de TsgcReportBuilder

Bandas, grupos y expresiones

Un verdadero diseño por bandas, de modo que los informes de negocio, como ventas por región o facturas por cliente, no necesitan apaños.

Un informe agrupado de Delphi con una cabecera por grupo, subtotales y números de página

Bandas y grupos

Título del informe, cabeceras, datos, pies y resumen

Un informe tiene bandas de título del informe, cabecera de página, cabecera de grupo, datos, pie de grupo, pie de página y resumen, además de cabeceras y pies de columna. Un grupo se rompe cuando cambia su expresión, imprime sus propios totales y puede iniciar una página nueva o repetir su cabecera en cada página. Los subinformes permiten que una página incluya el diseño de otra.

  • GroupExpression en una banda de cabecera de grupo, y grupos anidados para dos o más niveles
  • StartNewPage, RepeatOnEveryPage y KeepTogether controlan el flujo de páginas
  • PrintOnFirstPage y PrintOnLastPage deciden dónde aparecen las bandas de página
  • Tablas, tablas de referencias cruzadas, texto enriquecido, códigos de barras, casillas de verificación e imágenes SVG como elementos del informe
Lee el tema de ayuda

Expresiones

Totales, formatos y condiciones entre corchetes

Cualquier elemento de texto admite expresiones entre corchetes, evaluadas por el motor para cada fila, de modo que el total de un pie siempre coincide con las líneas impresas encima. Hay 68 funciones y 10 agregados, incluidos aritmética de fechas, relleno y formato, ToWords en 12 idiomas, agregados condicionales y valores acumulados que se reinician con cada grupo.

'[Sum(Lines.Qty * Lines.Price)]'
'[FormatDateTime(''dd/mm/yyyy'', Invoices.Date)]'
'Page [Page] of [TotalPages]'
  • Sum, FormatFloat, FormatDateTime, Upper, Round, IsNull, SumIf, CountIf, RunningSum y Previous
  • OnGetVariable aporta tus propias variables en tiempo de ejecución
  • Highlights aplica un estilo cuando una condición es verdadera, por ejemplo importes negativos en rojo, sin script
Lee el tema de ayuda

Datos de TDataSet, maestro detalle incluido

El informe lee tus datos donde ya están: una consulta, un documento JSON o tus propios objetos.

Un informe de factura construido a partir de datasets maestro y detalle, con sus líneas, totales y un código QR

Maestro detalle

Facturas y sus líneas a partir de dos datasets

TsgcReportDataSetSource lee cualquier TDataSet, como TClientDataSet, FireDAC o dbExpress. Una fuente de detalle se enlaza con su maestro por campos clave, de modo que cada factura imprime sus propias líneas y el pie de grupo las suma. Si el dataset está cerrado, se abre y se cierra alrededor de la ejecución; si ya está abierto, su estado y posición se restauran después.

  • MasterSource, MasterFields y DetailFields enlazan las fuentes
  • TsgcReportJSONSource lee una cadena o un archivo JSON, RecordsPath elige el array
  • TsgcReportEventSource obtiene filas de tu código mediante OnFirst, OnNext y OnGetValue
  • Los parámetros del informe se pasan a los parámetros de consulta del mismo nombre antes de la ejecución
Lee el tema de ayuda
srcInvoices.SourceName := 'Invoices';
srcInvoices.DataSet := cdsInvoices;
srcLines.SourceName := 'Lines';
srcLines.DataSet := cdsLines;
srcLines.MasterSource := srcInvoices;
srcLines.MasterFields := 'Number';
srcLines.DetailFields := 'Invoice';
sgcEngine.AddDataSource(srcInvoices);
sgcEngine.AddDataSource(srcLines);

Exporta un informe de Delphi a PDF, Excel, CSV y más

El motor prepara las páginas una sola vez, y cada exportación parte del mismo resultado preparado, así que las cifras son idénticas en todos los archivos.

El mismo informe exportado a PDF, a un libro de Excel y a un archivo CSV

Formatos de salida

Un informe preparado, todos los formatos

La exportación a PDF escribe PDF/UA-1 etiquetado por defecto, y PDF/A-3 para archivos a largo plazo. La salida XLSX conserva los números como números, de modo que la hoja de cálculo los suma sin limpieza. Toda exportación puede escribir en un archivo o en un flujo.

  • Todas las ediciones: PDF, PDF/A, PDF/UA, XLSX, CSV, PNG, HTML, ODS, SVG y texto sin formato
  • Edición Registered: DOCX, ODT y RTF
  • Salida PDF mediante la biblioteca PDF para Delphi sgcPDF, con fuentes incrustadas y códigos de barras vectoriales
Lee el tema de ayuda
FPages := sgcEngine.Prepare;
try
  pdfExport.SaveToFile(FPages, OutputFolder + 'orders.pdf');
  xlsxExport.SaveToFile(FPages, OutputFolder + 'orders.xlsx');
  csvExport.SaveToFile(FPages, OutputFolder + 'orders.csv');
  imageExport.SaveToFiles(FPages, OutputFolder + 'orders_%d.png');
finally
  FPages.Free;
end;

Vista previa e impresión de informes en VCL y FireMonkey

Los usuarios pasan las páginas del informe antes de imprimirlo o guardarlo, con el mismo renderizado que el PDF.

La ventana de vista previa de sgcReports en una aplicación Delphi con una página de factura y un código QR

Vista previa e impresión

Un control de vista previa con impresión y exportación

TsgcReportPreviewVCL muestra las páginas preparadas con navegación, zoom y modos de ajuste, las imprime y las guarda en PDF. Las vistas previas buscan texto con las coincidencias resaltadas, muestran miniaturas de página y exportan a PDF, Excel, CSV, PNG, HTML, Word, ODT, ODS, RTF, SVG y texto sin formato desde un menú Export. TsgcReportPreviewFMX es la vista previa de FireMonkey en Windows, macOS, iOS y Android.

  • FirstPage, NextPage, PriorPage y LastPage, ZoomIn, ZoomOut, FitWidth y FitPage
  • Parámetros de informe tipados con un aviso antes de preparar el informe
  • Recuentos de páginas y registros mientras se prepara un informe largo, con un botón Cancel
Lee el tema de ayuda
procedure TfrmMain.btnPreviewClick(Sender: TObject);
begin
  sgcPreview.Engine := sgcEngine;
  sgcPreview.Prepare;
end;

procedure TfrmMain.btnPrintClick(Sender: TObject);
begin
  sgcPreview.Print('Sales by region');
end;

Genera informes sin interfaz en servicios y daemons

Los extractos nocturnos, las facturas tras el pago y las exportaciones detrás de una API se ejecutan en un servidor sin ventana.

Sin VCL, sin DLL, sin controlador de impresora

El núcleo de sgcReports no tiene dependencia de VCL ni de FireMonkey y no necesita ninguna DLL externa ni controlador de impresora. TsgcReportEngine prepara informes sin ventana, en un servicio de Windows o en un daemon Linux64.

Un motor por hilo

Cada trabajador crea su propio informe, motor, fuentes de datos y exportaciones, mientras que un TsgcReportFontManager de solo lectura sirve a todos los hilos. sgcReportsConfigureForServer ajusta el gestor de memoria para muchos hilos en Windows.

Diseños del diseñador

Una definición guardada por el diseñador es un archivo JSON normal, así que un servidor la carga con sgcReportLoadFromJSONFile y la ejecuta sin interfaz. La demo ReportLinuxDaemon vigila una carpeta de trabajos y genera PDF, XLSX, CSV o PNG con 4 hilos de trabajo.

Tema de ayuda del daemon de Linux →

Trae tus plantillas de informe existentes

Una aplicación que pasa a sgcReports suele tener ya muchos informes. Conviértelos en lugar de dibujarlos de nuevo.

Importación de informes solo Registered

Importa plantillas .rtm de ReportBuilder y formularios de QuickReport

TsgcReportImporter convierte formularios de QuickReport (.dfm con un TQuickRep) y plantillas de ReportBuilder (.rtm), en texto o binario, en definiciones de informe, y enumera cada objeto, propiedad, expresión y script que no pudo asignar. Los diseñadores de VCL, FireMonkey, WinForms, WPF y Avalonia tienen un comando Import. Revisas la lista, añades las fuentes de datos, corriges el resto en el diseñador y guardas el resultado como definición JSON.

  • El formato se detecta solo, así que una sola llamada gestiona ambos tipos de archivo
  • Un pipeline de ReportBuilder o un conjunto de datos de QuickReport pasa a ser el nombre de una fuente de datos; DataSourceMap lo renombra con tu propia fuente
  • ImportResult guarda el resultado de la última importación, y los diseñadores muestran las incidencias en una ventana
Lee el tema de ayuda
oReport := TsgcReport.Create(nil);
oImporter := TsgcReportImporter.Create;
try
  // the old pipeline Orders is the data source Sales here
  oImporter.DataSourceMap.Values['Orders'] := 'Sales';
  try
    oImporter.ImportFromFile(oReport, 'orders.rtm');
    sgcReportSaveToJSONFile(oReport, 'orders.json');
  except
    on E: ESgcReportImportError do
      WriteLn('Not imported: ', E.Message);
  end;
finally
  oImporter.Free;
  oReport.Free;
end;

¿Migras una aplicación entera? El kit de migración de QuickReport asigna bandas y controles a sus equivalentes de sgcReports con pasos numerados.

Versiones de Delphi, plataformas y ediciones

DestinoQué se ejecutaPlataformas
Delphi 7 a 13Modelo de informe, expresiones, datos, diseño, motor, builder fluido y exportacionesWindows, Linux64, macOS, iOS y Android
C++ Builder 2007 a 13Las mismas clasesCabeceras .hpp generadas y bibliotecas estáticas
Diseñador y vista previa VCLTsgcVCLReportDesigner, TsgcReportPreviewVCLWindows
Diseñador y vista previa FireMonkeyTsgcFMXReportDesigner (Delphi XE6 y posteriores), TsgcReportPreviewFMXVista previa en Windows, macOS, iOS y Android

sgcReports se vende por separado desde €199 por desarrollador, con código fuente completo y 1 año de actualizaciones, y está incluido en sgcUI Enterprise y en el paquete All-Access. Escribe PDF a través de sgcPDF, que es obligatorio en toda configuración. Los diseñadores para usuarios finales, la importación de informes, la exportación a DOCX, ODT y RTF y el diseñador web están en la edición Registered; la prueba tiene todas las características desbloqueadas.

Ver precios Matriz de características

Preguntas sobre el generador de informes

Enlaza tus datos con un TsgcReportDataSetSource sobre un TDataSet, describe las bandas con TsgcReportBuilder y llama a SaveToPDF, como en el ejemplo de código de arriba. Si prefieres dibujar el diseño, coloca un TsgcReport, un TsgcReportEngine y un TsgcVCLReportDesigner en un formulario, diseña el informe y guárdalo como definición JSON. Ambos caminos producen el mismo modelo de informe.

Sí, en la edición Registered. TsgcVCLReportDesigner y TsgcFMXReportDesigner son diseñadores para usuarios finales que incrustas en tus formularios, y sgcShowReportDesigner abre uno de forma modal desde un menú. Para aplicaciones web, TsgcReportHTMLDesigner se ejecuta en el navegador. Todos los diseñadores guardan definiciones JSON que se cargan en cualquier parte de sgcReports.

Sí, en la edición Registered. TsgcReportImporter convierte plantillas de ReportBuilder (.rtm), en texto o binario, y formularios de QuickReport (.dfm con un TQuickRep) en definiciones de informe, y enumera cada objeto, propiedad, expresión y script que no pudo asignar. Los diseñadores tienen un comando Import que hace lo mismo. Consulta Trae tus plantillas de informe existentes.

Sí. SaveToPDF y SaveToXLSX en el builder, o TsgcReportPDFExport y TsgcReportXLSXExport sobre páginas preparadas, escriben PDF/UA-1 etiquetado (PDF/A-3 si lo pides) y libros de Excel que conservan los números como números. CSV, PNG, HTML, ODS, SVG y texto sin formato están en todas las ediciones, y DOCX, ODT y RTF en la edición Registered.

Asigna el motor a un TsgcReportPreviewVCL y llama a Prepare. La vista previa pagina, amplía, busca texto y exporta, y Print imprime el documento mostrado. Las aplicaciones FireMonkey usan TsgcReportPreviewFMX en Windows, macOS, iOS y Android.

Sí. El núcleo no tiene dependencia de VCL ni de FireMonkey y ninguna DLL externa, así que TsgcReportEngine y las exportaciones se ejecutan en servicios de Windows y en daemons Linux64, con un motor por hilo. La demo ReportLinuxDaemon genera trabajos desde una carpeta con 4 hilos de trabajo.

Delphi 7 a 13 y C++ Builder 2007 a 13. TsgcReportBuilder es una clase simple que funciona en Delphi 7, sin necesidad de métodos anónimos. El diseñador de FireMonkey necesita Delphi XE6 o posterior. Las mismas clases están disponibles para .NET.

Sí, siempre. sgcReports escribe PDF y dibuja códigos de barras con el motor sgcPDF, y las vistas previas dibujan mediante el control visor de sgcPDF. sgcUI Enterprise incluye ambos.

La mejor opción: All-AccessTodos los productos de eSeGeCe, con Premium Support incluido, desde €1,059 al año.
Ver precios de All-Access

Prueba el generador de informes

La prueba de sgcUI incluye sgcReports, sus diseñadores y sgcPDF, con todas las características desbloqueadas.