Delphi, C++ Builder y .NET Parte de sgcUI

sgcReports, el motor de informes para Delphi, C++ Builder y .NET

Diseña un informe una vez y entrégalo como PDF accesible, archivo de Excel, CSV o páginas PNG. Constrúyelo en código con una cadena fluida o carga una definición JSON en tiempo de ejecución, con grupos, subtotales, maestro-detalle y códigos de barras. El motor no necesita ventana ni DLL externas, así que funciona en servicios y demonios Linux64.

PDF etiquetado PDF/UA-1 por defectoPDF, XLSX, CSV y PNGServicios de Windows y Linux64Incluido en sgcUI Enterprise
Ventana de vista previa de sgcReports con una página de factura y un código QR

Todo lo que necesita un motor de informes

Once funciones, cada una con la API real y el tema de ayuda que la respalda.

Diseña el informe

Describe un informe en código o en JSON, con bandas, grupos y expresiones de verdad.

Escribe un informe completo en pocas líneas legibles

Diseña el informe

Escribe un informe completo en pocas líneas legibles

Los diseñadores de informes son geniales hasta que el diseño tiene que vivir en el control de versiones, revisarse en una pull request o generarse a partir de tus propios metadatos. TsgcReportBuilder describe estilos, páginas, bandas y elementos como una única cadena fluida, así que un informe es código normal que se compila, se compara y se refactoriza con el resto de tu proyecto. La misma cadena prepara el informe y lo guarda en todos los formatos de salida. Los informes construidos así pueden generarse en un bucle, compartirse como funciones y cubrirse con pruebas unitarias como cualquier otro código.

  • Style, Page, GroupHeader, MasterData, GroupFooter y PageFooter se leen como el propio diseño
  • SaveToPDF, SaveToXLSX, SaveToCSV y SaveToPNG directamente desde el constructor
  • Variantes de flujo como SaveToPDFStream para respuestas web
  • El constructor rellena un modelo TsgcReport normal que aún puedes ajustar en código
  • De derecha a izquierda para árabe y hebreo: RightToLeft en el informe y BiDiMode en bandas y elementos reflejan el diseño, con texto árabe y hebreo conformado en las salidas PDF, XLSX y HTML
Leer el tema de la ayuda
Grupos, subtotales y números de página que simplemente funcionan

Diseña el informe

Grupos, subtotales y números de página que simplemente funcionan

Los informes de negocio rara vez son una lista plana: ventas por región, facturas por cliente, existencias por almacén. sgcReports tiene un diseño por bandas de verdad con bandas de título del informe, encabezado de página, encabezado de grupo, datos, pie de grupo, pie de página y resumen. Un grupo se rompe cuando cambia su expresión, imprime sus propios totales y puede empezar una página nueva o repetir su encabezado en cada página, de modo que los informes largos siguen siendo legibles. Los subinformes permiten que una página incluya el diseño de otra, para resúmenes y anexos.

  • GroupExpression en una banda de encabezado de grupo, grupos anidados para dos o más niveles
  • StartNewPage, RepeatOnEveryPage y KeepTogether controlan el flujo de páginas
  • Tipos de banda desde rbtReportTitle hasta rbtReportSummary, además de encabezados y pies de columna
  • TotalPages en expresiones para pies del tipo "Página 2 de 7"
  • PrintOnFirstPage y PrintOnLastPage deciden dónde aparecen las bandas de página; SubreportPageName incrusta otra página
Leer el tema de la ayuda
Facturas directamente desde tu base de datos

Diseña el informe

Facturas directamente desde tu base de datos

Una factura es un registro maestro con sus líneas, y cada línea necesita el producto, la cantidad y el precio correctos. Una fuente de dataset enlaza cualquier TDataSet, FireDAC incluido, y vincula una fuente de detalle con su maestro mediante campos clave, de modo que cada factura imprime sus propias líneas y totales. Los arrays JSON y tus propias fuentes basadas en eventos funcionan igual cuando los datos no viven en una base de datos. La banda de detalle se repite por cada línea del registro maestro actual, y el pie imprime el total de la factura con una expresión de agregado sobre las líneas.

  • TsgcReportDataSetSource con MasterSource, MasterFields y DetailFields
  • TsgcReportJSONSource lee una cadena o un archivo JSON, RecordsPath elige el array
  • TsgcReportEventSource obtiene filas de tu código mediante OnFirst, OnNext y OnGetValue
  • Las fuentes se registran en el motor con AddDataSource
Leer el tema de la ayuda
Cambia un informe sin recompilar

Diseña el informe

Cambia un informe sin recompilar

Una columna nueva en el extracto mensual no debería exigir una nueva versión de tu aplicación. Las definiciones de informe pueden guardarse y cargarse desde JSON, así que los diseños pueden vivir en una base de datos, en una carpeta de configuración o en un directorio específico de un cliente. La aplicación carga la definición en tiempo de ejecución, enlaza los datos y la renderiza, y el mismo archivo alimenta el diseñador web. Las definiciones son texto plano, así que se comparan limpiamente en el control de versiones y pueden generarse con tus propias herramientas o migrarse con un script.

  • sgcReportLoadFromJSON y sgcReportSaveToJSON, además de variantes de archivo y flujo
  • sgcReportGenerateSchema escribe un esquema JSON para editores y validación
  • Los errores indican la ruta JSON del miembro que falla
  • La demo ReportJSONDefinition edita una definición y sus datos lado a lado
Leer el tema de la ayuda
Expresiones y códigos de barras en cualquier banda

Diseña el informe

Expresiones y códigos de barras en cualquier banda

Los totales, las fechas con formato, el texto condicional y las etiquetas de envío se reducen a expresiones y códigos de barras. Cualquier elemento de texto puede contener expresiones entre corchetes, como una suma con formato de un campo, con funciones de cadena, número y fecha integradas. Los códigos de barras también son elementos, dibujados como vectores por el motor sgcPDF, así que las etiquetas y los albaranes se imprimen nítidos a cualquier tamaño. El motor evalúa las expresiones para cada fila, de modo que el total de un pie siempre coincide con las líneas impresas arriba.

  • Agregados y funciones: Sum, FormatFloat, FormatDateTime, Upper, Round, IsNull
  • OnGetVariable proporciona tus propias variables en tiempo de ejecución
  • Barcode en el constructor con rbsCode128, rbsEAN13, rbsQRCode, rbsDataMatrix, rbsPDF417 y más
  • GS1-128, ITF, Codabar, UPC-A y Code 39 para etiquetas de logística
Leer el tema de la ayuda

Entrégalo donde sea

Prepara una vez y exporta a los formatos que piden tus usuarios y los reguladores.

PDF accesible por defecto, PDF/A bajo petición

Entrégalo donde sea

PDF accesible por defecto, PDF/A bajo petición

Los organismos públicos y muchas empresas deben ahora publicar documentos que los lectores de pantalla puedan seguir, y los archivos necesitan ficheros que aún se abran dentro de veinte años. La exportación a PDF escribe PDF/UA-1 etiquetado por defecto, con un orden de lectura lógico, texto alternativo para las imágenes y encabezados marcados. Activa PDF/A-3 cuando el documento vaya a un archivo a largo plazo. En Delphi y .NET, la exportación también escribe PDF/A-4 y PDF/UA-2. Las fuentes se incrustan mediante el mismo gestor de fuentes que usa la vista previa, y la ayuda explica cómo validar un archivo con la herramienta gratuita veraPDF.

  • PDFUA es True por defecto en TsgcReportPDFExport
  • AltText y TagRole en los elementos describen imágenes y encabezados
  • PDFA con rpaA3b o rpaA3a para salida de archivo
  • FixedDocumentID y FixedCreationDate hacen que la salida sea reproducible byte a byte para las pruebas
Leer el tema de la ayuda
Un informe, todos los formatos que piden tus usuarios

Entrégalo donde sea

Un informe, todos los formatos que piden tus usuarios

Finanzas quiere el extracto en Excel, el cliente quiere un PDF, la integración quiere un CSV y la página web quiere una miniatura. El motor prepara las páginas una vez y cada exportación trabaja sobre el mismo resultado preparado, así que las cifras son idénticas en todos los archivos. La salida XLSX mantiene los números como números, de modo que la hoja de cálculo puede sumarlos sin limpieza. Cada exportación también puede escribir en un flujo, que es lo que necesita una respuesta web o un adjunto de correo, y SaveToFiles escribe varios formatos en una sola llamada.

  • TsgcReportPDFExport, TsgcReportXLSXExport, TsgcReportCSVExport, TsgcReportImageExport
  • TsgcReportPreparedPages con LoadPrepared alimenta varias exportaciones desde una sola ejecución
  • DetectNumbers, SheetName y ExcludePageBands dan forma a la hoja de cálculo
  • Páginas PNG con los DPI que pases a SaveToPNG
Leer el tema de la ayuda
Una ventana de vista previa para aplicaciones de escritorio

Entrégalo donde sea

Una ventana de vista previa para aplicaciones de escritorio

Los usuarios quieren hojear un informe antes de imprimirlo o guardarlo. El control de vista previa muestra las páginas preparadas con el mismo renderizado que el PDF, con navegación por páginas, zoom, modos de ajuste y una barra de herramientas que puedes ocultar cuando construyes la tuya. La vista previa VCL funciona en Windows; la de FireMonkey funciona en Windows. La vista previa dibuja mediante el control visor de sgcPDF, así que lo que los usuarios ven en pantalla es lo que escribe la exportación a PDF, y SaveToPDF en la vista previa guarda las páginas que están mirando.

  • TsgcReportPreviewVCL con FirstPage, NextPage, PriorPage y LastPage
  • ZoomIn, ZoomOut, FitWidth y FitPage
  • ShowToolbar, CurrentPage y OnPageChange para tu propia navegación
  • TsgcReportPreviewFMX: vista previa FireMonkey en Windows
Leer el tema de la ayuda

Entrégalo donde sea

Funciona sin ventana en servicios y demonios Linux

Hoy la mayoría de los informes se generan en un servidor: extractos nocturnos, facturas tras la compra, exportaciones detrás de una API. El núcleo de sgcReports no tiene dependencia de VCL ni de FireMonkey y no necesita DLL externas ni controlador de impresora, así que el mismo código funciona en un servicio de Windows o en un demonio Linux64. La ayuda documenta un patrón de grupo de trabajadores en el que cada hilo tiene su propio motor. Los trabajos, los datos y las definiciones de informe pueden llegar como archivos JSON, de modo que un demonio puede alimentarse desde cualquier sistema capaz de escribir un archivo.

  • TsgcReportEngine prepara informes sin ventana
  • La demo ReportLinuxDaemon vigila una carpeta de trabajos y renderiza PDF, XLSX, CSV o PNG con 4 hilos de trabajo
  • sgcReportsConfigureForServer ajusta el gestor de memoria para muchos hilos en Windows
  • Un TsgcReportFontManager compartido y de solo lectura sirve a todos los hilos
Leer el tema de la ayuda

Informes en la web

El puente sgcReportsHTML sirve informes por HTTP y permite a los usuarios editar diseños en el navegador.

Informes en la web Solo registrada

Sirve informes por HTTP

Un portal web, una intranet o una aplicación móvil a menudo solo necesitan una URL que devuelva el informe. El endpoint HTTP registra informes por nombre en un servidor HTTP de sgcWebSockets y los sirve como PDF, XLSX, CSV o PNG, con un visor HTML que pide los parámetros, recorre el resultado por páginas y ofrece las descargas. Tu código rellena los datos en un evento antes de cada ejecución. El endpoint usa las mismas definiciones de informe y fuentes de datos que tu código de escritorio, así que un informe escrito una vez sirve tanto a la aplicación como al navegador.

  • TsgcReportHTTPEndpoint con RegisterReport y BasePath
  • OnBeforePrepare define parámetros y datos por petición
  • TsgcReportHTMLViewer con ShowParameters para un formulario de parámetros
  • Funciona sobre TsgcWebSocketHTTPServer; la demo ReportHTTPServer es un servidor completo

Delphi y C++ Builder: necesita sgcWebSockets Professional o superior y sgcHTML. .NET: los paquetes esegece.sgcReports.HTML y AspNetCore alojan las mismas rutas.

Leer el tema de la ayuda

Informes en la web Solo registrada

Un diseñador web de informes para tus usuarios

Los usuarios avanzados siempre quieren una columna más o una agrupación distinta, y cada cambio solía ser un ticket para los desarrolladores. El diseñador del navegador edita la definición JSON de un informe con un lienzo de bandas, un inspector de propiedades y una vista previa en vivo, servido por el mismo endpoint que el informe terminado. Tú decides quién puede editar, y las definiciones guardadas se cargan en cualquier otra parte de sgcReports. Un botón Descargar JSON entrega la definición a quien quiera conservarla.

  • TsgcReportHTMLDesigner en un endpoint con DesignerEnabled
  • Árbol de páginas, bandas y elementos, arrastrar, redimensionar y ajustar en milímetros, deshacer y rehacer
  • Inspector de propiedades generado a partir del esquema JSON del informe; la validación en el servidor señala el campo
  • Las definiciones guardadas se cargan con sgcReportLoadFromJSON en cualquier sitio, incluido el demonio Linux

Deja DesignerEnabled desactivado en los endpoints de producción y ponlo detrás de tu propia autenticación.

Leer el tema de la ayuda

Mira sgcReports en acción

sgcReports dentro de las demos de la suite sgcUI: aplicaciones completas que funcionan sin conexión con datos simulados integrados.

Quién construye con sgcReports

Facturas, albaranes y extractos

Las aplicaciones de gestión imprimen a diario documentos desde su base de datos. Una fuente de dataset con maestro-detalle vincula cada factura con sus líneas, los grupos y los pies imprimen los totales, un código QR o un código de barras GS1-128 va en la etiqueta, y la exportación a PDF escribe un archivo accesible listo para enviar por correo. El mismo informe se guarda en XLSX para el equipo de contabilidad.

  • Maestro-detalle
  • Grupos y subtotales
  • Códigos de barras
  • PDF accesible
Ejecuta la demo ReportInvoice

Informes en servidor para portales web

Los portales de clientes y las API internas necesitan informes a demanda. Registra los informes en el endpoint HTTP y el navegador obtiene un visor con parámetros y descargas, o ejecuta el motor en un demonio Linux64 que renderiza trabajos en cola con un grupo de trabajadores. No intervienen controlador de impresora, ventana ni DLL externas. Las mismas definiciones JSON sirven al visor y al demonio.

  • Sirve informes por HTTP
  • Demonio Linux
  • Definiciones JSON
Ejecuta la demo ReportHTTPServer

Obligaciones de accesibilidad y archivo

Los proveedores del sector público y las empresas reguladas deben publicar documentos que los lectores de pantalla puedan seguir y archivarlos durante años. La salida PDF/UA-1 etiquetada es la predeterminada, el texto alternativo y los roles de encabezado viven en los elementos del informe, y PDF/A-3 está a una propiedad de distancia. La ayuda muestra cómo comprobar el resultado con el validador gratuito veraPDF. La salida reproducible ayuda a que las pruebas automatizadas comparen archivos.

  • PDF accesible
  • PDF/A-3
  • Salida reproducible
Ejecuta la demo ReportPDFUA

Un informe de ventas agrupado en pocas líneas

La misma API en Delphi, C++ Builder y C#: un encabezado por región, una línea por venta y un subtotal por región, guardado como PDF, XLSX y CSV.

Un informe fluido sobre una fuente JSON: un grupo por región con un subtotal, guardado como PDF, XLSX y CSV.

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

const
  CS_SALES = '[' +
    '{"Region":"East","Customer":"Acme Corp","Amount":1450.00},' +
    '{"Region":"East","Customer":"Blue Harbor","Amount":600.00},' +
    '{"Region":"North","Customer":"Nordic Labs","Amount":2100.75},' +
    '{"Region":"North","Customer":"Fjord Ltd","Amount":880.20}]';
  CS_TOTAL = '[FormatFloat(''#,0.00'', Sum(Sales.Amount))]';

procedure ExportSalesReport(const aFolder: string);
var
  oSales: TsgcReportJSONSource;
  oBuilder: TsgcReportBuilder;
begin
  oSales := TsgcReportJSONSource.Create(nil);
  oBuilder := TsgcReportBuilder.Create;
  try
    oSales.SourceName := 'Sales';
    oSales.JSON := CS_SALES;
    oBuilder.Title('Sales by region').Author('eSeGeCe').Units(ruMillimeters)
      .Style('Base').Font('Arial', 10).EndStyle
      .Style('Group').Font('Arial', 11).Bold.BackColor($EEEEEE).EndStyle
      .Page.Paper(rpsA4).Margins(15)
      // one header per region, one line per sale, a subtotal per region
      .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);
    // accessible PDF (PDF/UA is on by default), plus the same data as Excel
    oBuilder.SaveToPDF(IncludeTrailingPathDelimiter(aFolder) + 'sales.pdf');
    oBuilder.SaveToXLSX(IncludeTrailingPathDelimiter(aFolder) + 'sales.xlsx');
    oBuilder.SaveToCSV(IncludeTrailingPathDelimiter(aFolder) + 'sales.csv');
  finally
    oBuilder.Free;
    oSales.Free;
  end;
end;

Leer el tema de la ayuda →

El mismo informe en C++ Builder con las cabeceras generadas de sgcReports.

#include <vcl.h>
#include "sgcReports_Types.hpp"
#include "sgcReports_Model.hpp"
#include "sgcReports_Data.hpp"
#include "sgcReports_Fluent.hpp"

void ExportSalesReport(const String Folder)
{
  const String Total = "[FormatFloat('#,0.00', Sum(Sales.Amount))]";
  TsgcReportJSONSource *Sales = new TsgcReportJSONSource(NULL);
  TsgcReportBuilder *Builder = new TsgcReportBuilder();
  try
  {
    Sales->SourceName = "Sales";
    Sales->JSON = "[{\"Region\":\"East\",\"Customer\":\"Acme Corp\",\"Amount\":1450.00},"
                  "{\"Region\":\"East\",\"Customer\":\"Blue Harbor\",\"Amount\":600.00},"
                  "{\"Region\":\"North\",\"Customer\":\"Nordic Labs\",\"Amount\":2100.75}]";
    Builder->Title("Sales by region")->Author("eSeGeCe")->Units(ruMillimeters)
      ->Style("Base")->Font("Arial", 10)->EndStyle()
      ->Style("Group")->Font("Arial", 11)->Bold()->BackColor(0xEEEEEE)->EndStyle()
      ->Page("")->Paper(rpsA4, roPortrait)->Margins(15)
      // one header per region, one line per sale, a subtotal per region
      ->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 " + Total, 80, 1, 100, 6)->AlignRight()->Bold()->EndBand()
      ->EndPage()->Data(Sales);
    // accessible PDF (PDF/UA is on by default), plus the same data as Excel
    Builder->SaveToPDF(IncludeTrailingPathDelimiter(Folder) + "sales.pdf");
    Builder->SaveToXLSX(IncludeTrailingPathDelimiter(Folder) + "sales.xlsx");
    Builder->SaveToCSV(IncludeTrailingPathDelimiter(Folder) + "sales.csv");
  }
  __finally
  {
    delete Builder;
    delete Sales;
  }
}

Leer el tema de la ayuda →

La misma cadena de constructor en C#, con los mismos nombres de clase que en Delphi.

using System.IO;
using esegece.sgcReports;

public static class SalesReport
{
    const string Sales = "[" +
        "{\"Region\":\"East\",\"Customer\":\"Acme Corp\",\"Amount\":1450.00}," +
        "{\"Region\":\"East\",\"Customer\":\"Blue Harbor\",\"Amount\":600.00}," +
        "{\"Region\":\"North\",\"Customer\":\"Nordic Labs\",\"Amount\":2100.75}," +
        "{\"Region\":\"North\",\"Customer\":\"Fjord Ltd\",\"Amount\":880.20}]";
    const string Total = "[FormatFloat('#,0.00', Sum(Sales.Amount))]";

    public static void Export(string aFolder)
    {
        using (TsgcReportJSONSource oSales = new TsgcReportJSONSource())
        using (TsgcReportBuilder oBuilder = new TsgcReportBuilder())
        {
            oSales.SourceName = "Sales";
            oSales.JSON = Sales;
            oBuilder.Title("Sales by region").Author("eSeGeCe").Units(TsgcReportUnits.ruMillimeters)
                .Style("Base").Font("Arial", 10).EndStyle()
                .Style("Group").Font("Arial", 11).Bold().BackColor(0xEEEEEE).EndStyle()
                .Page().Paper(TsgcReportPaperSize.rpsA4).Margins(15)
                // one header per region, one line per sale, a subtotal per region
                .GroupHeader("Sales.Region", 9).Style("Group")
                .Text("Region: [Sales.Region]", 0, 1, 180, 7)
                .TagRole(TsgcReportTagRole.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 " + Total, 80, 1, 100, 6).AlignRight().Bold().EndBand()
                .EndPage().Data(oSales);
            // accessible PDF (PDF/UA is on by default), plus the same data as Excel
            oBuilder.SaveToPDF(Path.Combine(aFolder, "sales.pdf"));
            oBuilder.SaveToXLSX(Path.Combine(aFolder, "sales.xlsx"));
            oBuilder.SaveToCSV(Path.Combine(aFolder, "sales.csv"));
        }
    }
}
dotnet add package esegece.sgcReports

Leer el tema de la ayuda →

Ejecuta las demos de sgcReports

Con sgcReports se incluyen diez demos de Delphi, ocho de C++ Builder y diez de .NET. Las tarjetas de abajo son los proyectos Delphi; la mayoría tiene un gemelo en C++ Builder y otro en .NET con el mismo nombre.

ReportInvoice

ReportInvoice

Una factura maestro-detalle desde datasets: encabezado, líneas, totales y un código QR, en la vista previa y como PDF.

ReportGroups

ReportGroups

Ventas agrupadas por región con encabezados de grupo, subtotales y un total general en la banda de resumen.

ReportFluent

ReportFluent

Un informe completo escrito con el constructor fluido y exportado después a todos los formatos.

ReportJSONDefinition

ReportJSONDefinition

Edita una definición JSON y sus datos en dos memos y renderízala, con errores que apuntan a la ruta JSON.

ReportPDFUA

ReportPDFUA

Salida PDF/UA-1 etiquetada con texto alternativo y roles de encabezado, lista para una comprobación con veraPDF.

ReportExports

ReportExports

Un informe preparado escrito como archivos PDF, XLSX, CSV y PNG.

ReportDatabaseSQL

ReportDatabaseSQL

Un informe alimentado por consultas SQL mediante fuentes de dataset.

ReportMobileFMX

La vista previa FireMonkey con navegación por páginas. La vista previa FireMonkey funciona en Windows.

ReportLinuxDaemon

Un demonio de consola para Windows y Linux64 que renderiza trabajos JSON en cola con un grupo de hilos de trabajo.

Solo registrada ReportHTTPServer

Informes servidos por HTTP con el visor del navegador, parámetros y descargas. Necesita sgcWebSockets y sgcHTML.

Demos compiladas

Ejecutables listos para usar de cada producto sgcUI, sin nada que instalar.

Descargar sgcUI_bin.zip →

Dónde se incluye sgcReports

sgcReports forma parte de sgcUI Enterprise y también se vende por separado. Usa el motor sgcPDF para la salida PDF y los códigos de barras, así que sgcPDF es necesario en cualquier configuración. sgcReports también está incluido en el paquete All-Access.

Paquete individual de sgcReports

€199 / desarrollador, código fuente completo, 1 año de actualizaciones.

Comprar sgcReports → Ver precios →

sgcUI Enterprise

Los 14 productos sgcUI, desde €699.

Ver Enterprise →

Los paquetes .NET Community gratuitos (esegece.sgcReports.Community, .WinForms.Community, .HTML.Community, .AspNetCore.Community) incluyen el motor, las exportaciones y la vista previa. En Delphi, el instalador Community ofrece sgcReports solo cuando hay un sgcPDF con licencia instalado. El puente sgcReportsHTML para Delphi y C++ Builder es solo registrado.

FunciónCommunity (gratuita)Registrada
Constructor fluido, modelo de informe y definiciones JSON✓✓
Bandas, grupos, maestro-detalle y expresiones✓✓
Códigos de barras✓✓
Exportación PDF/UA y PDF/A-3✓✓
Exportación XLSX, CSV y PNG✓✓
Vista previa WinForms✓✓
Motor sin ventana para servicios y Linux✓✓
Puente sgcReportsHTML para Delphi y C++ Builder (endpoint HTTP, visor, diseñador web)−✓

Frameworks y plataformas compatibles

Componentes de sgcReports

Motor y modelo

TsgcReport, TsgcReportEngine y el TsgcReportBuilder fluido.

Fuentes de datos

TsgcReportDataSetSource, TsgcReportJSONSource y TsgcReportEventSource.

Exportaciones

TsgcReportPDFExport, TsgcReportXLSXExport, TsgcReportCSVExport y TsgcReportImageExport.

Vista previa

TsgcReportPreviewVCL y TsgcReportPreviewFMX, la vista previa FireMonkey que funciona en Windows.

Puente sgcReportsHTML

TsgcReportHTTPEndpoint, TsgcReportHTMLViewer y TsgcReportHTMLDesigner. Necesita sgcWebSockets Professional o superior y sgcHTML. Registrada

.NET

Los mismos nombres de clase en el espacio de nombres esegece.sgcReports: el constructor, las fuentes, el motor y las exportaciones.

DestinoComponentePlataformas
Delphi 7 a 13Modelo, expresiones, datos, diseño, motor y exportacionesWindows, Linux64, macOS, iOS y Android
C++ Builder 2007 a 13Las mismas clasesCabeceras .hpp generadas y bibliotecas estáticas
Vista previa VCLTsgcReportPreviewVCLWindows
Vista previa FireMonkeyTsgcReportPreviewFMXWindows
.NETConstructor, fuentes, motor, exportaciones y la vista previa WinFormsWindows, además de uso sin ventana en Linux

Preguntas frecuentes

Sí, siempre. sgcReports escribe PDF y dibuja códigos de barras con el motor sgcPDF. sgcUI Enterprise incluye ambos. En el instalador Delphi Community, sgcReports se ofrece solo cuando hay un sgcPDF con licencia instalado. El motor PDF es también el que dibuja la estructura etiquetada de los archivos PDF accesibles.

Sí, en el navegador. TsgcReportHTMLDesigner, del puente sgcReportsHTML, edita definiciones de informe JSON con un lienzo de bandas, un inspector de propiedades y una vista previa en vivo. En código, el constructor fluido y las definiciones JSON cubren el mismo modelo. Las definiciones guardadas se cargan igual en aplicaciones de escritorio, servicios y demonios.

Sí. El núcleo no tiene dependencia de VCL ni de FireMonkey ni DLL externas, así que el motor y las exportaciones funcionan en aplicaciones de consola y demonios Linux64. La demo ReportLinuxDaemon y el tema del demonio Linux incluyen una unidad systemd. El mismo código también funciona en servicios de Windows.

PDF (PDF/UA-1 etiquetado por defecto, PDF/A-3 bajo petición), XLSX, CSV y páginas PNG. Todos trabajan a partir de las mismas páginas preparadas, así que un informe se prepara una vez y se exporta tantas veces como necesites. Cada exportación puede escribir en un archivo o en un flujo, para respuestas web y adjuntos de correo.

Sí, con un motor por hilo. Cada trabajador crea su propio informe, motor, fuentes de datos y exportaciones, mientras que un gestor de fuentes y una definición JSON de solo lectura pueden compartirse. El tema Seguridad de hilos muestra el patrón de grupo de trabajadores. Un servidor Windows también puede llamar una vez a sgcReportsConfigureForServer al arrancar cuando use muchos hilos.

Sí. Guarda las definiciones de informe como JSON y cárgalas en tiempo de ejecución con sgcReportLoadFromJSON, de modo que un diseño nuevo no necesita una nueva compilación. Los usuarios pueden editarlas en el diseñador web, o tu aplicación puede generarlas. Los errores al cargar indican la ruta JSON del miembro que falla, lo que facilita dar soporte a diseños específicos de cada cliente.

Sí. TsgcReportPreviewVCL muestra las páginas preparadas con navegación, zoom y modos de ajuste. TsgcReportPreviewFMX es la vista previa FireMonkey en Windows, y .NET tiene una vista previa WinForms. La vista previa dibuja mediante el control visor de sgcPDF, así que la pantalla coincide con la exportación a PDF.

Ayuda de sgcReports

3,000+Desarrolladores
20+Años
761+Componentes
30+Integraciones de API
5Plataformas
Garantía de devolución de 30 días¿No estás satisfecho? Solicita un reembolso completo en los 30 días posteriores a la compra. Ver política de reembolso

Prueba sgcReports hoy

La prueba de sgcUI incluye sgcReports, sgcPDF y todos los demás productos sgcUI.