sgcReports 2026.11: importa i tuoi report di FastReport, più parametri, tabelle e modelli per Delphi, C++ Builder e .NET

La maggior parte dei team che vorrebbero lasciare il proprio motore di report non lo fa mai, per un solo motivo: centinaia di report esistenti che nessuno vuole disegnare di nuovo. sgcReports 2026.11 elimina questo ostacolo. Legge i tuoi file di FastReport, QuickReport e ReportBuilder e li converte, e colma le lacune che un team verifica prima di cambiare: parametri di report, un vero elemento tabella, modelli di report con ereditarietà, un'anteprima con ricerca e miniature, e un output PDF per le fatture elettroniche.

Tutto ciò che segue funziona allo stesso modo in Delphi e C++ Builder, con VCL e FireMonkey, e in .NET con WinForms, WPF e Avalonia. Ogni esempio di codice di questa pagina è stato compilato ed eseguito sui sorgenti 2026.11.

• 01Importatore di reportFile di FastReport, QuickReport e ReportBuilder, convertiti.
• 02Parametri di reportValori tipizzati richiesti dall'anteprima, anche via HTTP.
• 03Elemento tabellaCelle unite, righe di intestazione ripetute, totali.
• 04Nuovi tipi di elementoCaselle di controllo, SVG, sparkline e gauge.
• 05Modelli ed ereditarietàUna sola carta intestata per tutti i report.
• 06Un'anteprima miglioreRicerca, miniature e un menu di esportazione.
• 07Segnalibri e collegamentiUn indice PDF, collegamenti ipertestuali e ancore.
• 08PDF per fatture elettronicheFactur-X, ZUGFeRD e XRechnung in PDF/A-3.
• 09Libreria di espressioni68 funzioni e 10 aggregati.
• 10HighlightsStili condizionali senza script.
• 11Avanzamento e annullamentoPer i report grandi, a schermo e sul server.
• 12Ogni piattaformaLa stessa API in Delphi e .NET.

Parte 1 · Elimina il costo del cambio

Importa i report di FastReport, QuickReport e ReportBuilder

Il nuovo TsgcReportImporter legge un file .fr3 di FastReport, un modulo QuickReport (un .dfm con un TQuickRep) o un modello .rtm di ReportBuilder, in formato testo o binario, e lo trasforma in una definizione di report di sgcReports. Pagine, bande, elementi, stili e origini dati vengono trasferiti, le espressioni sono tradotte nella sintassi di sgcReports e le caselle di controllo di QuickReport e ReportBuilder diventano il nuovo elemento casella di controllo.

Ciò che lo rende sicuro da usare in un progetto reale è l'altra metà del risultato. L'importatore elenca ogni oggetto, proprietà, espressione, script e origine dati che non ha potuto mappare, con il percorso all'interno del report e il motivo, così sai esattamente cosa completare a mano. Nulla viene scartato in silenzio.

I designer hanno un comando Importa, quindi un report può essere portato dentro, controllato nell'anteprima e salvato come JSON senza scrivere codice. Da codice bastano quattro righe più la pulizia:

  oImporter := TsgcReportImporter.Create;
  try
    oImporter.ImportFromFile(oReport, 'fr_items.fr3');
    for i := 0 to oImporter.ImportResult.Issues.Count - 1 do
      Writeln(oImporter.ImportResult.Issues[i].Reason);
  finally
    oImporter.Free;
  end;

E lo stesso in C#:

    var oImporter = new TsgcReportImporter();
    oImporter.ImportFromFile(oReport, "fr_items.fr3");
    foreach (var oIssue in oImporter.ImportResult.Issues)
      Console.WriteLine(oIssue.Reason);

Script, testo formattato, grafici e tabelle incrociate del report di origine non vengono convertiti. Compaiono nell'elenco dei problemi, così puoi ricostruirli con gli equivalenti di sgcReports. La nuova demo ReportImport, per Delphi, C++ Builder e .NET, importa file di esempio di tutti e tre i formati.

Parametri di report, richiesti dall'anteprima

Un report può ora dichiarare i propri parametri: testo, intero, numero, data, data e ora, oppure sì o no, ciascuno con un valore predefinito o un'espressione predefinita, un flag di obbligatorietà, valori multipli e un elenco di valori consentiti, fisso o letto da un'origine dati. Espressioni e script li leggono come :Name.

Non devi scrivere un modulo per gestirli. Le anteprime e i designer VCL e FireMonkey chiedono i parametri prima che il report venga preparato, e lo stesso fanno le anteprime .NET. Il visualizzatore HTML mostra un modulo di parametri tipizzato, e l'endpoint HTTP legge ?param.Name=value dalla query string e risponde 400 a un valore non valido, invece di restituire un report difettoso.

In una definizione JSON i parametri si trovano accanto alle pagine:

"parameters": [
  { "name": "FromDate", "dataType": "rpdtDate", "required": true,
    "defaultExpression": "EncodeDate(2026, 1, 1)" },
  { "name": "MinTotal", "dataType": "rpdtFloat", "defaultValue": "0" }
]

Un servizio che prepara il report senza un utente imposta i valori nel codice, e non viene mostrata alcuna richiesta:

  oEngine.Report := oReport;
  oEngine.SetParameterValue('FromDate', VarFromDateTime(EncodeDate(2026, 3, 1)));
  oEngine.SetParameterValue('MinTotal', 100.0);

Un vero elemento tabella

Allineare a mano elementi di testo per simulare una tabella è finito. Il nuovo elemento tabella ha larghezze di colonna fisse, in percentuale e automatiche, celle che si estendono su più righe e colonne, righe di intestazione che si ripetono in ogni pagina, righe di dati che provengono da una propria origine dati, righe a piè di tabella con i totali e righe che crescono con il contenuto. Le celle supportano stili, Highlights e collegamenti ipertestuali.

Le esportazioni mantengono la struttura. Una tabella diventa una tabella con tag in un PDF accessibile, con celle di intestazione, il loro ambito e le estensioni, così uno screen reader la legge come una tabella. Diventa una tabella HTML, una tabella Word con le righe di intestazione ripetute e celle unite in XLSX. Nel codice, il builder fluente la scrive in poche righe:

  oTable := oBuilder.Page('Main').Paper(rpsA4).Margins(15).ReportTitle(14)
    .CanGrow.Table(0, 0, 180, 'Products');
  oTable.Column(25).Column(0, rtwmAuto).Column(30)
    .HeaderRow(['Products', '', '']).RowStyle('Title').Cell(0, 0).Span(1, 3)
    .HeaderRow(['Code', 'Name', 'Price']).RowStyle('Head')
    .DataRow(['[Products.Code]', '[Products.Name]', '[Products.Price]'])
    .Cell(1, 2).Format('#,##0.00');
  oTable.Table.RepeatHeaderRows := True;

Caselle di controllo, SVG, sparkline e gauge

Quattro novità da disegnare su una pagina:

• Elemento casella di controllo, selezionato da un'espressione booleana, con un segno di spunta, una croce o un quadrato. Rimane vettoriale nel PDF e diventa un valore TRUE o FALSE in XLSX e CSV.
• Immagini SVG negli elementi immagine, stampate come grafica vettoriale nel PDF, come SVG in HTML e come immagini nitide in Word, così un logo resta nitido a qualsiasi zoom.
• Elemento sparkline, disegnato da sgcCharts: linea, area, colonne oppure vittorie e sconfitte, uno per riga.
• Elemento gauge, disegnato da sgcGauges, radiale o lineare con intervalli colorati, tramite il nuovo bridge sgcReportsGauges.

Le impostazioni degli elementi personalizzati ora accettano espressioni, valutate per ogni banda stampata, ed è così che ogni riga disegna la propria sparkline e il proprio gauge:

  oBand := oPage.MasterData('Projects', 14);
  oBand.CheckBox('Projects.Done', 4, 4, 6, 6).Name('DoneBox');
  oBand.Item.CheckBox.CheckStyle := rcsCheck;
  oBand.Custom('Sparkline', 75, 1, 60, 12, ['values=[Projects.Trend]',
    'kind=area', 'markers=last,high']).Name('Trend');
  oBand.Custom('Gauge', 140, 2, 50, 10, ['value=[Projects.Progress]',
    'gaugeKind=linear', 'unit=%']).Name('ProgressGauge');

Modelli di report ed ereditarietà

Ogni azienda ha una carta intestata, e ogni fattura, estratto conto e documento di trasporto la ripete. Con la nuova proprietà InheritsFrom, "inheritsFrom" nel JSON, una definizione di report parte da una definizione di base e memorizza solo le proprie differenze. Pagine, bande, elementi e stili vengono uniti per nome. Un report figlio può sovrascrivere una proprietà, aggiungere un elemento, collocare una banda per prima con "$first" o eliminare un elemento ereditato con "$remove". Cambia il logo nel report di base e tutti i report che lo ereditano lo seguono.

L'intero documento di trasporto qui sopra è fatto di poche righe di differenze. Qui rimuove il blocco dei contatti della carta intestata:

"inheritsFrom": "letterhead.json",
"pages": [ { "name": "Page1", "bands": [
  { "name": "PageHeader", "items": [
    { "name": "Contact", "$remove": true }
  ] }
] } ]

  oDef.BaseFolder := ExtractFilePath(ExpandFileName('letterhead.json'));
  oDef.LoadFromFile(oReport, 'child.json');

La base viene cercata in BaseFolder, oppure il tuo gestore OnResolveBase la carica da un database o da una risorsa. Le catene arrivano fino a otto livelli, e Flat scrive la definizione unita quando serve un unico file. I designer VCL, FireMonkey e HTML contrassegnano gli oggetti ereditati, li modificano come sovrascritture e creano un nuovo report a partire da un report di base. Nel designer VCL, una proprietà sovrascritta appare in grassetto.

Un'anteprima con ricerca, miniature e menu di esportazione

Le anteprime hanno una barra di ricerca (Ctrl+F, F3, maiuscole/minuscole e parola intera) che evidenzia ogni corrispondenza nella pagina, un pannello di miniature delle pagine e un menu Esporta per PDF, XLSX, CSV, PNG, HTML e Word, con un evento OnExport per gestire in proprio il salvataggio. È disponibile nelle anteprime VCL e FireMonkey e nelle anteprime WinForms, WPF e Avalonia, e anche il visualizzatore PDF FireMonkey ottiene la ricerca del testo.

  oPreview.ShowThumbnails := True;
  oPreview.ExportFormats := [rpxPDF, rpxXLSX];
  if oPreview.SearchText('Total', False, True) then
    Writeln(oPreview.SearchResults, ' match(es)');

Parte 2 · Colma le lacune

Segnalibri PDF, collegamenti ipertestuali e ancore

Imposta la nuova espressione Bookmark su una banda o su un elemento, e l'esportazione PDF scrive i segnalibri come indice del documento, annidati per gruppo, mentre le anteprime VCL e FireMonkey li mostrano in un pannello di struttura (ShowOutline). La nuova proprietà Hyperlink apre un indirizzo web o mailto, oppure salta a un'Anchor nello stesso report con #name, e i collegamenti vengono mantenuti nelle esportazioni PDF, HTML, Word e XLSX.

PDF per fatture elettroniche: Factur-X, ZUGFeRD e XRechnung

L'esportazione PDF incorpora l'XML della fattura elettronica della tua applicazione come file associato PDF/A-3 tramite la nuova proprietà EInvoice, per Factur-X, ZUGFeRD e XRechnung, anche come PDF/A-3a con PDF/UA. La fattura che leggono le persone e i dati che leggono le macchine viaggiano in un unico file. sgcReports non scrive l'XML da sé: lo fornisce la tua applicazione.

Una libreria di espressioni con 68 funzioni e 10 aggregati

La libreria di espressioni cresce fino a 68 funzioni e 10 aggregati. Sono nuovi l'aritmetica delle date, il riempimento e la formattazione, Choose, ToWords per scrivere un importo in lettere nelle 12 lingue di sgcUI, e gli aggregati SumIf, CountIf, Previous, RunningSum e RunningCount. Un aggregato segue la banda in cui viene stampato: un piè di gruppo dà il totale del gruppo, un piè di pagina il totale della pagina.

Highlights: stili condizionali senza script

Gli Highlights associano a un elemento un elenco di condizioni e stili. La prima condizione vera sostituisce lo stile dell'elemento, così i totali negativi si stampano in rosso e i buoni risultati in verde senza una riga di script. Sono presenti nel JSON, nel builder fluente e nei designer VCL, FireMonkey e HTML.

Avanzamento e annullamento per i report grandi

Il motore ha un nuovo evento OnProgress con i conteggi di pagine e record e un metodo Cancel. Le anteprime mostrano l'avanzamento mentre un report viene preparato, con un pulsante Annulla che si preme anche con Esc, e l'endpoint HTTP ha i nuovi limiti MaxPages e Timeout, così un solo report fuori controllo non può bloccare un server.

Ogni piattaforma, la stessa API

Ogni funzionalità di questa pagina è disponibile per Delphi e C++ Builder, con le anteprime e i designer VCL e FireMonkey, e per .NET con WinForms, WPF e Avalonia, con gli stessi nomi di classi e proprietà. I report definiti in JSON passano da un mondo all'altro senza modifiche, e il motore continua a funzionare senza interfaccia nei servizi e nei daemon Linux64.

Con questa versione arrivano cinque nuove demo, per Delphi, C++ Builder e .NET: ReportImport, ReportParameters, ReportTables, ReportVisualItems e ReportInheritance, accanto alla demo ReportEInvoice.

Altre novità di sgcReports 2026.11

• Un designer di report nativo per VCL e FireMonkey con toolbox, struttura, ispettore, righelli, guide, aggancio, annulla e ripeti, modifica da tastiera e supporto per gli screen reader.
• Scripting con un sottoinsieme di Pascal, modificato e controllato nei designer VCL e FireMonkey.
• Esportazione DOCX (modalità fissa e flusso) ed esportazione HTML (a pagine e continua), anche tramite le route HTTP.
• Elementi personalizzati, una tabella incrociata nativa ed elementi grafico e tabella pivot tramite i bridge sgcReportsCharts e sgcReportsPivotGrid.
• Filigrane e un'anteprima FireMonkey che funziona su macOS, iOS e Android.

L'importatore di report e gli elementi sparkline e gauge richiedono un'edizione registrata. sgcReports è incluso in sgcUI Enterprise e in All-Access, ed è venduto anche separatamente.

Domande o commenti? Contattaci, riceverai una risposta da chi ha scritto il codice.