XFA naar AcroForm flatten in Delphi met HotPDF

Twee formulieren kunnen dezelfde velden dragen en totaal anders gedragen. Een AcroForm houdt zijn velden als gewone PDF-objecten bovenop echte pagina-inhoud, dus elke conforme reader tekent het. Een dynamisch XFA-formulier houdt bijna niets als PDF vast: de velden, de layout, zelfs de pagina-geometrie leven in een XML-pakket, en de zichtbare pagina's worden bij openen geproduceerd door een layout-engine die alleen Adobe ooit breed uitleverde. Voed dat bestand aan een web-viewer, een archief-renderer of een tekst-extractor en u krijgt het formulier niet. U krijgt één grijze pagina die "Please wait... If this message is not eventually replaced by the proper contents of the document, your PDF viewer may not be able to display this type of document." leest. Iedereen die overheids- of verzekeringspaperwerk heeft ingenomen kent die pagina op het gezicht

De placeholder is geen corruptie. Het is precies wat het formaat specificeert dat er moet gebeuren wanneer geen XFA-processor aanwezig is, en vanaf 2026 beschrijft dat vrijwel elke viewer buiten desktop Acrobat. Dus de praktische zet is het dynamische formulier naar een gewone AcroForm te converteren voordat het iets downstream bereikt. HotPDF, de losLab PDF-bibliotheek voor Delphi en C++Builder, doet die conversie in code, en herbouwt het XML-formulier als native velden op native pagina's

Waarom de twee modellen niet naast elkaar kunnen bestaan

AcroForm is gedefinieerd in ISO 32000-1 §12.7. Elk veld is een PDF-object met een widget-annotatie en een appearance-stream, de pagina is echte PDF-inhoud, en de data rijdt erbovenop. XFA keert dat om: het formulier is een XML-document, een XDP-pakket opgeslagen in de /XFA-entry van de AcroForm-dictionary, en de PDF-pagina's van een dynamisch formulier houden de "Please wait"-placeholder en niets anders vast, omdat de echte inhoud nooit als PDF werd geserialiseerd. Een reader verwerkt een bestand als het ene of het andere model. Negeer de /XFA-entry en u ziet de lege schil; eer hem zonder een XFA-engine en u ziet de waarschuwing. ISO 32000-2 beëindigde het debat door XFA uit PDF 2.0 te droppen, wat de hoofdreden is dat "converteer zolang we nog kunnen" van een edge-case in routine intake-policy veranderde

Classificeer alles voordat u het converteert, want niet elk XFA-bestand toont de placeholder. Statische XFA-formulieren leveren pre-renderde PDF-pagina's naast de XML, dus ze vertonen overal en misdragen alleen bij invullen. Dynamische formulieren leveren de placeholder alleen en zijn onbruikbaar tot conversie. Vertrouw het document, nooit de extensie of de afzender. Een bestand dat echte inhoud rendert in een niet-Adobe viewer maar toch een /XFA-entry draagt, is statisch of hybride; een bestand dat de waarschuwingspagina toont is dynamisch. Noteer in welke bucket elk intake-bestand landde. De twee soorten breken later op verschillende manieren, en een ticket over een leeg gearchiveerd formulier wordt in seconden gesloten wanneer het intake-log al "dynamic XFA, converted, 47 fields mapped, 2 warnings" leest

Een geladen XFA-document converteren naar native velden

De conversie draait tegen een document dat al in het geheugen staat. FlattenLoadedXFA parseert het XFA-template en zijn data-pakketten, legt het formulier uit, en herbouwt het als AcroForm-velden op echte PDF-pagina's:

var
  Pdf: THotPDF;
  MappedCount, I: Integer;
  Warnings: TStrings;
begin
  Pdf := THotPDF.Create(nil);
  try
    Pdf.LoadFromFile('dynamic_xfa.pdf');
    MappedCount := Pdf.FlattenLoadedXFA(True);   // True = velden blijven bewerkbaar
    Warnings := Pdf.XFAFlattenWarnings;
    for I := 0 to Warnings.Count - 1 do
      Log('XFA flatten warning: ' + Warnings[I]); // niet-gemapte elementen
    Pdf.SaveLoadedDocument('native_acroform.pdf');
    Log(Format('Mapped %d fields', [MappedCount]));
  finally
    Pdf.Free;
  end;
end;

De returnwaarde en de waarschuwingslijst zijn output, geen debug-ruis, dus houd beide bij. Conversie verliest van nature informatie: XFA-scripting, berekende velden en dynamisch subform-gedrag hebben geen AcroForm-tegenhanger, en XFAFlattenWarnings noemt elk template-element dat niet mappen kon. Archiveer het geconverteerde bestand zonder zijn waarschuwingslijst en op een dag staart u naar een lege totalen-vak in een gearchiveerde kopie zonder registratie van waarom. De Editable-vlag bepaalt of de nieuwe velden invulbaar blijven. Geef True mee wanneer mensen achteraf met het formulier blijven werken, en sluit de waarden af wanneer het doel een bevroren registratie is

Een conversie controleren is deels visueel, deels structureel, en u hebt beide helften nodig. De structurele helft is makkelijk: bevestig dat het veldaantal overeenkomt met MappedCount. De visuele helft is degene die echte schade vangt. Open het bronformulier in desktop Acrobat, nog steeds de enige viewer die de XFA-engine draait, naast het geconverteerde bestand in een gewone reader, en vergelijk waarden en layout op ten minste één ingevuld voorbeeld per sjabloon. Een datum die de XFA-engine als 2026-06-11 toonde kan in de AcroForm-kopie landen als een rauwe, ongeformateerde waarde, en alleen uw ogen vangen dat

Wanneer de input een XDP-pakket is

Niet elke klus begint vanaf een gevulde PDF. Soms ontvangt u het XDP-pakket alleen, geëxporteerd vanuit een formulier-ontwerptool of overhandigd door een partnersysteem. ApplyXFAAsAcroForm dropt de load-stap en past het pakket direct toe op het huidige document:

XDPBytes := TFile.ReadAllBytes('benefit-claim.xdp');
MappedCount := Pdf.ApplyXFAAsAcroForm(XDPBytes, True);

Dezelfde groep aanroepen draait ook de andere kant op, voor het zeldzamere geval waarin u XFA moet emitten in plaats van consumeren. AddXFAPacket hecht individuele genoemde pakketten zoals 'xdp' of 'config'. SetXFADocument installeert een complete single-stream-payload in één aanroep. ClearXFAPackets wist de registratie zodat u opnieuw kunt beginnen, en AddXFASignaturePacket embedt XAdES-materiaal voor workflows die de XML-formulierdata direct ondertekenen. XFA produceren in 2026 is een nichebehoefte, vrijwel altijd afgedwongen door één legacy-consument die iets anders weigert, maar wanneer een contract het noemt houden deze aanroepen het bij een configuratiekeuze in plaats van een apart gereedschap

De andere betekenis van "flatten"

Het woord "flatten" laat veel gesprekken struikelen, want het noemt een tweede bewerking in het geheel: AcroForm-veld-appearances in de pagina-content-stream branden tot er geen interactieve objecten meer over zijn. HotPDF heeft daar vandaag geen API voor, en u wilt het nu weten in plaats van halverwege een project. Wat de bibliotheek u in plaats daarvan geeft is vergrendeling op veldniveau wanneer het veld wordt gecreëerd, ondersteund door documenttoestemmingen:

// Vergrendel de waarde bij veldcreatie: alleen-lezen tekstveld
Pdf.CurrentPage.AddTextField('CaseNumber', 'BC-2026-0117',
  Rect(50, 700, 220, 720), 0, [ffReadOnly]);

// Dubbele beveiliging: beperk het invullen van formulieren voor het hele document
Pdf.ActivateProtection := True;
Pdf.CryptKeyLength := aes256;
Pdf.OwnerPassword := 'records-owner';
Pdf.ProtectOptions := [prPrint, prInformationCopy, prExtractContent];
// invultoestemming onthouden: prFillAnnotations ontbreekt in de set

Wees duidelijk over wat dat u oplevert en wat niet. Een read-only-veld is nog steeds een formulierobject. Het duikt op in het veldpaneel van de viewer, zijn waarde is leesbaar via de form-API, en een tool die het bestand herschrijft kan de read-only-vlag weer wissen. Toestemmingsvlaggen tillen de lat maar zijn afhankelijk van de viewer die kiest ze te respecteren, een beperking die ISO 32000-1 ronduit stelt. Wanneer een regulator erop staat dat een gearchiveerde registratie helemaal geen formulierobjecten bevat, is het eerlijke antwoord met HotPDF vandaag het document te herbouwen: lees de waarden uit, en teken ze dan als gewone TextOut-inhoud op een verse pagina, in plaats van read-only-vlaggen als flattening te verkleden. Eén ding om op de toestemmingsroute te onthouden is dat CryptKeyLength vóór BeginDoc ingesteld moet zijn; de rest staat in ons AES-256-versleutelings- en toestellingsartikel

Wat XFA voor archiefconformiteit betekent

PDF/A en PDF/X wijzen XFA allebei ronduit af. Een pipeline die een ISO 19005-archief voedt moet dus eerst converteren, en de volgorde is niet onderhandelbaar: load, FlattenLoadedXFA, save, voer dan archief-generatie of -validatie uit op het AcroForm-resultaat. Beschouw conversie niet als bewijs van conformiteit. Het fixt het formuliermodel en laat lettertypen, kleur en metadata precies zoals ze waren, dus valideer de output met veraPDF voordat u hem vertrouwt. Zodra het formulier aan de AcroForm-zijde staat, krijgt zijn gedrag zijn eigen set controles. JavaScript-triggers, submit-acties en validatiescripts worden behandeld in het HotPDF-artikel over AcroForm-velden en -acties

De XFA-registratie-, conversie- en formulier-API's die hier getoond worden worden geleverd met de HotPDF Delphi Component voor Delphi en C++Builder, wiens documentatie de XFA-feature-set volgt zoals die over recente releases is gegroeid