Exemples de scripts décrivant une exportation

Cet exemple de code montre comment récupérer la valeur d'un champ pendant une exportation. Vous pouvez utiliser cette valeur pour nommer les fichiers dans lesquels les images ou les données sont exportées. S'il n'y a pas de champ de ce type dans le document, une erreur se produira.will occur.

Structure du document à exporter :

Section 1
           Field1
           …
           Group1
                       Field2
                       …
           …
           FieldN
Section 2
           Field1
           …
           FieldK

[VBScript]
Dim field1Value, field2Value
' Récupère la valeur de Field1 dans la Section 1
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
   field1Value = me.Field( "Section 1\Field1" ).Value
end if
' Récupère la valeur de Field2 dans Group1 dans la Section 1
if Not IsNull( me.FIELD( "Section 1\Group1\Field2" ).Value ) then
   field2Value = me.Field( "Section 1\Group1\Field2" ).Value
end if
' Récupère la valeur de Field1 dans Section 1 si la section comporte plusieurs instances
if Not me.Field( "Section 1" ).Items Is Nothing then
   dim curPage
   for each curPage in me.Field( "Section 1" ).Items
       if Not curPage.Children Is Nothing then
           dim curField
           for each curField in curPage.Children
               if curField.Name = "Field1" And Not IsNull( curField.Value )  then
                    field1Value = curField.Value
                    exit for
               end if
           next
       end if
   next
end if
[JScript]
// Récupère la valeur de Field1 dans Section 1
if( Field("Section 1\\Field1").Value != null ) {
var field1Value = Field("Section 1\\Field1").Value;
}
// Récupère la valeur de Field2 dans Group1, Section 1
if( Field("Section 1\\Group1\\Field2").Value != null ) {
var field2Value = Field("Section 1\\Group1\\Field2").Value;
}
// Récupère la valeur de Field1 dans Section 1 si la section comporte plusieurs instances
if( Field( "Section 1" ).Items != null ) {
   var i, j;
   for( i = 0; i < Field( "Section 1" ).Items.Count; i++ ) {
       var curPage = Field( "Section 1" ).Items.Item( i );
       if( curPage.Children != null ) {
           for( j = 0; j < curPage.Children.Count; j++ ) {
               var curField = curPage.Children.Item( j );
               if( curField.Name == "Field1" && curField.Value != null ) {
                    var field1Value  = curField.Value;
                    break;
               }
           }
       }
   }
}

Le code de cet exemple montre comment exporter des images de toutes les pages d'un document en utilisant le format de fichier requis, le système de couleurs requis et la résolution requise. Les images sont enregistrées page par page. Chaque page est donc stockée dans un fichier distinct.

Les fichiers de cet exemple sont nommés « page1.tif », « page2.tif », etc. Vous pouvez modifier le mécanisme de dénomination des fichiers si nécessaire. Par exemple, vous pouvez créer des noms de fichiers à partir de la valeur d'un champ.

[VBScript]
dim fso, folderName
set fso = CreateObject("Scripting.FileSystemObject")
folderName = "d:\ExportImages"
if Not fso.FolderExists( folderName ) then
   fso.CreateFolder folderName
end if
dim imageOptions
set imageOptions = FCTools.NewImageSavingOptions
imageOptions.Format = "tif"
imageOptions.ColorType = "BlackAndWhite"
imageOptions.Resolution = 600
dim i
for i = 0 to me.Pages.Count - 1
   dim fileName
   ' Définit l'extension et le nom souhaités pour le fichier, en fonction du format sélectionné
   fileName = fso.BuildPath( folderName, "page" & (i+1) & ".tif" )
   me.Pages.Item(i).SaveAs fileName, imageOptions
next
[JScript]
var fso = new ActiveXObject("Scripting.FileSystemObject");
var folderName = "d:\\ExportImages";
if( !fso.FolderExists( folderName ) ) {
   fso.CreateFolder( folderName );
}
var imageOptions = FCTools.NewImageSavingOptions();
imageOptions.Format = "tif";
imageOptions.ColorType = "BlackAndWhite";
imageOptions.Resolution = 600;
var i;
for( i = 0; i < Pages.Count; i++ ) {
   // Définit l'extension et le nom souhaités pour le fichier, en fonction du format sélectionné
   var fileName = fso.BuildPath( folderName, "page" + (i+1) + ".tif" );
   Pages.Item(i).SaveAs( fileName, imageOptions );
}

Cet exemple montre comment exporter un tableau vers un fichier *.txt

[VBScript]
dim fso, txtFile, fileName
set fso = CreateObject("Scripting.FileSystemObject")
fileName = "d:\TestExportTable.txt"
set txtFile = fso.CreateTextFile( fileName, true )
txtFile.WriteLine "Table"
dim table, row, cell, rowNumber
set table = me.Field("Page 1\Table")
rowNumber = 1
for each row in table.Items
  txtFile.WriteLine "RowNumber = " & rowNumber
   for each cell in row.Children
       txtFile.Write cell.Value & "   "
   next
   txtFile.WriteBlankLines 1
   rowNumber = rowNumber + 1
next
txtFile.Close
set txtFile = nothing
set fso = nothing
[JScript]
var fso, txtFile, fileName;
fso = new ActiveXObject("Scripting.FileSystemObject");
fileName = "d:\\TestExportTable1.txt";
txtFile = fso.CreateTextFile( fileName, true );
txtFile.WriteLine( "Table" );
var table, i, j;
table = Field("Page 1\\Table");
var rows = table.Items;
for( i = 0; i < rows.Count; i++ ) {
   txtFile.WriteLine( "RowNumber = " + ( i+1 ) );
   var cells = rows.Item(i).Children;
   for( j = 0; j < cells.Count; j++ ) {
      txtFile.Write( cells.Item(j).Value + "   " );
   }
   txtFile.WriteBlankLines(1);
}
txtFile.Close();

Cet exemple montre comment exporter des champs d'un document, quel que soit son niveau d'imbrication, en utilisant des fonctions personnalisées, que vous créez vous-même, à partir du module d'exportation global. S'il vous faut exporter des champs d'un document présentant une imbrication variable, il est recommandé d'utiliser un composant COM externe (voir l'exemple suivant).

Code d'exportation de base

[VBScript]
Export.ExportDocument me, FCTools

[JScript]
Export.ExportDocument( this, FCTools );

Code des fonctions du module d'exportation global

[VBScript]
' La procédure effectue l'exportation : elle crée un dossier d'exportation et
' enregistre dans ce dernier des fichiers image de pages, le fichier texte contenant les champs du document,
' et des informations relatives au document
Sub ExportDocument(ByRef docObj, ByRef FCTools)
   Dim folderName
   Dim txtFile, fileName
   Dim fso
   On Error Resume Next
   set fso = CreateObject("Scripting.FileSystemObject")
   ' création du dossier d'exportation
   folderName = CreateExportFolder(docObj.DefinitionName, fso)
   if Err.Number <> 0 then
       docObj.Action.Succeeded = false
       docObj.Action.ErrorMessage = "Error during create export folder: " + Err.Description
       Err.Clear
       Exit Subub
   End if
   ' exportation d'images
   ExportImages docObj, FCTools, folderName, fso
   if Err.Number <> 0 then
       docObj.Action.Succeeded = false
       docObj.Action.ErrorMessage = "Erreur lors de l'exportation d'images : " + Err.Description
       Err.Clear
       Exit Sub
   End if
   ' création du fichier texte
   fileName = fso.BuildPath(folderName, "doc.txt")
   Set txtFile = fso.CreateTextFile(fileName, True)
   ' exportation des informations concernant le document
   ExportDocInfo docObj, txtFile
   ' exportation des champs
   txtFile.WriteLine "Fields:"
   ExportFields docObj.Children, txtFile, ""
   txtFile.Close
   if Err.Number <> 0 then
       docObj.Action.Succeeded = false
       docObj.Action.ErrorMessage = "Erreur lors de l'exportation de données : " + Err.Description
       Err.Clear
       Exit Sub
   End if
   Set txtFile = Nothing
   Set fso = Nothing
End Sub
' Fonction d'exportation d'images
Function ExportImages( ByRef docObj, ByRef FCTools, ByVal exportFolder, ByRef fso )
   Dim pages, page, imageOptions
   Dim fileName, pageNum
   ' spécificationdes paramètres d'exportation
   Set imageOptions = FCTools.NewImageSavingOptions
   imageOptions.Format = "bmp"
   imageOptions.ColorType = "FullColor"
   imageOptions.Resolution = 100
   ' exportation page par page
   Set pages = docObj.Pages
   pageNum = 1
   For Each page In pageses
       fileName = fso.BuildPath(exportFolder, "page" & pageNum & ".bmp")
       page.SaveAs fileName, imageOptions
       pageNum = pageNum + 1
   Next
End Function
' Procédure d'exportation des informations concernant le document
Sub ExportDocInfo(ByRef docObj, ByRef txtFile)
   txtFile.WriteLine "Doc info:"
   txtFile.WriteLine ("DocumentId " & docObj.Id)
   txtFile.WriteLine ("IsAssembled " & docObj.IsAssembled)
   txtFile.WriteLine ("IsVerified " & docObj.IsVerified)
   txtFile.WriteLine ("IsExported " & docObj.IsExported)
   txtFile.WriteLine ("ProcessingErrors " & docObj.ProcessingErrors)
   txtFile.WriteLine ("ProcessingWarnings " & docObj.ProcessingWarnings)
   txtFile.WriteLine ("TotalSymbolsCount " & docObj.TotalSymbolsCount)
   txtFile.WriteLine ("RecognizedSymbolsCount " & docObj.RecognizedSymbolsCount)
   txtFile.WriteLine ("UncertainSymbolsCount " & docObj.UncertainSymbolsCount)
   txtFile.WriteLine
End Sub
' Procédure d'exportation des champs à partir de l'ensemble de champs
Sub ExportFields(ByRef fields, ByRef txtFile, ByVal indent)
   Dim curField
   For Each curField In fields
       ExportField curField, txtFile, indent
   Next
End Sub
' Vérifie si la valeur du champ est nulle
' Si la valeur du champ n'est pas valide, toute tentative d'accès à ce champ (y compris
' pour en vérifier la nullité) peut générer une exception
Function IsNullFieldValue( ByRef field )
   on error resume next
   IsNullFieldValue = IsNull( field.Value )
   if Err.Number <> 0 then
       IsNullFieldValue = True
       Err.Clear
   End if
End Function
' Procédure d'exportation des champs
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)
   ' enregistrement du nom des champs
   txtFile.Write (indent & field.Name)
   ' enregistrement de la valeur des champs accessibles
   If IsNullFieldValue(field) Then
       txtFile.WriteLine
   Else
       txtFile.WriteLine ("    " & field.Text)
   End If
   If Not field.Children Is Nothing Then
       ' exportation des champs enfants
       ExportFields field.Children, txtFile, indent & "    "
   ElseIf Not field.Items Is Nothing Then
       ' exportation des instances de champs
       ExportFields field.Items, txtFile, indent & "    "
   End If
End Sub
' La fonction crée un dossier d'exportation et retourne le chemin d'accès complet de ce dossier
Function CreateExportFolder(ByVal definitionName, ByRef fso)
   Dim docFolder, folderName
   ' dossier principal
   exportFolder = "d:\ScriptExport"
   If fso.FolderExists(exportFolder) = False Then
       fso.CreateFolder (exportFolder)
   End If
   ' le dossier de la définition de document spécifiée
   docFolder = fso.BuildPath(exportFolder, definitionName)
   If fso.FolderExists(docFolder) = False Then
       fso.CreateFolder (docFolder)
   End If
   ' le dossier du document exporté
   Dim i
   i = 1
   folderName = fso.BuildPath(docFolder, i)
   While fso.FolderExists(folderName)
       i = i + 1
       folderName = fso.BuildPath(docFolder, i)
   Wend
   fso.CreateFolder (folderName)
   CreateExportFolder = folderName
End Function

[JScript]
// La fonction effectue l'exportation : elle crée un dossier d'exportation et
// enregistre dans ce dernier des fichiers image de pages, le fichier texte contenant les champs du document
// et des informations relatives au document
function ExportDocument(docObj, exportImageTools)
{    var folderName
   var txtFile, fileName
   var fso
   fso = new ActiveXObject("Scripting.FileSystemObject");
   // création des dossiers d'exportation
   try {
       folderName = CreateExportFolder(docObj.DefinitionName, fso);
   } catch( e ) {
       docObj.Action.Succeeded = false;
       docObj.Action.ErrorMessage = "Erreur lors de l'exportation d'images : " + e.description;
       return;n;
   }
   // exportation d'images
   try {
       ExportImages(docObj, exportImageTools, folderName, fso);
   } catch( e ) {
       docObj.Action.Succeeded = false;
       docObj.Action.ErrorMessage = "Erreur lors de l'exportation d'images : " + e.description;
       return;
   }
   // création du fichier texte
   fileName = fso.BuildPath(folderName, "doc.txt");
   txtFile = fso.CreateTextFile(fileName, true);
   // exportation des informations concernant le document
   ExportDocInfo( docObj, txtFile );
   // exportation des champs
   txtFile.WriteLine( "Fields:" );
   try {
       ExportFields( docObj.Children, txtFile, "" );
   } catch( e ) { {
       docObj.Action.Succeeded = false;
       docObj.Action.ErrorMessage = "Erreur lors de l'exportation d'images : " + e.description;
       txtFile.Close();
       return;
   }
   txtFile.Close();
   txtFile = 0;
   fso = 0;
}
// Fonction d'exportation d'images. If an error occurs when exporting images,
// it returns a message about the error; otherwise, it returns an empty string
function ExportImages( docObj, exportImageTools, exportFolder, fso )
{
   // spécification des paramètres d'exportation
   var imageOptions = exportImageTools.NewImageSavingOptions();
   imageOptions.Format = "bmp";
   imageOptions.ColorType = "FullColor";
   imageOptions.Resolution = 100;
   // exportation page par page
   var pages = docObj.Pages;
   var i
   for( i = 0; i < pages.Count; i++ ) {
       var fileName = fso.BuildPath( exportFolder, "page" + (i+1) + ".bmp" );
       pages.Item(i).SaveAs( fileName, imageOptions );
   }
}
// Procédure d'exportation des informations concernant le document
function ExportDocInfo(docObj, txtFile)
{
   txtFile.WriteLine( "Doc info:" );
   txtFile.WriteLine("IsAssembled " + docObj.IsAssembled);
   txtFile.WriteLine("IsVerified " + docObj.IsVerified);
   txtFile.WriteLine("IsExported " + docObj.IsExported);
   txtFile.WriteLine("ProcessingErrors " + docObj.ProcessingErrors);
   txtFile.WriteLine("ProcessingWarnings " + docObj.ProcessingWarnings);
   txtFile.WriteLine("TotalSymbolsCount " + docObj.TotalSymbolsCount);
   txtFile.WriteLine("RecognizedSymbolsCount " + docObj.RecognizedSymbolsCount);
   txtFile.WriteLine("UncertainSymbolsCount " + docObj.UncertainSymbolsCount);
   txtFile.WriteLine();
}
// Procédure d'exportation des champs à partir de l'ensemble de champs
function ExportFields(fields, txtFile, indent)
{
   var i
   for( i = 0; i < fields.Count; i++ ) {
       ExportField( fields.Item(i), txtFile, indent );
   }
}
// Vérifie si la valeur du champ est nulle
// Si la valeur du champ n'est pas valide, toute tentative d'accès à ce champ (y compris
// pour en vérifier la nullité) peut générer une exception
function IsNullFieldValue( field )
{
   try {
       return ( field.Value == null );
   } catch( e ) {
       return true;
   }
}
// Procédure d'exportation des champs
function ExportField(field, txtFile, indent)
{
   // enregistrement du nom des champs
   txtFile.Write(indent + field.Name);
   // enregistrement de la valeur des champs accessibles
   if( IsNullFieldValue( field ) ) {
       txtFile.WriteLine();
   } else {
       txtFile.WriteLine("    " + field.Text);
   } }
   if( field.Children != null ) {
       // exportation des champs enfants
       ExportFields( field.Children, txtFile, indent + "    " );
   } else if( field.Items != null ) {
       // exportation des instances de champs
       ExportFields( field.Items, txtFile, indent + "    " );
   }
}
// La fonction crée un dossier d'exportation et retourne le chemin d'accès complet de ce dossier
function CreateExportFolder(definitionName, fso)
{
   var docFolder, folderName
   // dossier principal
   var exportFolder = "d:\\ScriptExport";
   if( !fso.FolderExists(exportFolder) ) {
       fso.CreateFolder (exportFolder);
   } }
   // le dossier de la définition de document spécifiée
   docFolder = fso.BuildPath(exportFolder, definitionName);
   if( !fso.FolderExists(docFolder) ) {
       fso.CreateFolder(docFolder);
   }
   // le dossier du document exporté
   var i = 1;
   folderName = fso.BuildPath(docFolder, i);
   while( fso.FolderExists(folderName) ) {
       i++;
       folderName = fso.BuildPath(docFolder, i);
   }
   fso.CreateFolder(folderName);
   return folderName;
}

[VBScript]
dim autoExport
set autoExport = CreateObject( "AutomationExport.Exporter" )
autoExport.Export me, FCTools
[JScript]
var autoExport = new ActiveXObject("AutomationExport.Exporter");
autoExport.Export( this, FCTools );

Code d'un composant ActiveX en VisualBasic

Vous trouverez ci-dessous un code de classe Exporter issu du projet AutomationExport, qui est utilisé dans les scripts ci-dessus.

OptionExplicit
Dim mFso AsNew Scripting.FileSystemObject
' La procédure exécute l'exportation du document : elle crée un dossier d'exportation et
' enregistre dans ce dernier des fichiers image de pages, le fichier texte contenant les champs du document
' et des informations relatives au document
PublicSub Export(ByRef docObj As Object, ByRef FCTools As Object)
OnErrorGoTo err_h
   Dim folderName AsString
   Dim txtFile As TextStream, fileName AsString
   Dim imageExportResult AsString, errMessage AsString
   ' création du dossier d'exportation
   folderName = createExportFolder(docObj.definitionName)
   If folderName = "" Then
       docObj.Action.Succeeded = False
       docObj.Action.ErrorMessage = "Impossible de créer le dossier d'exportation"
       ExitSub
   EndIf
   ' exportation d'images
   imageExportResult = exportImages(docObj, FCTools, folderName)
   ' création du fichier texte
   fileName = mFso.BuildPath(folderName, "doc.txt")
   Set txtFile = mFso.CreateTextFile(fileName, True)
   ' enregistrement des informations sur les problèmes d'exportation d'images
   If imageExportResult <> "" Then
       txtFile.WriteLine imageExportResult
       errMessage = errMessage & imageExportResult
   EndIf
   ' exportation des informations concernant le document
   exportDocInfo docObj, txtFile
   ' exportation des champs
   txtFile.WriteLine "Fields:"
   IfNot exportFields(docObj.Children, txtFile, "") Then
      errMessage = errMessage & " Erreur lors de l'exportation des données"
   EndIf
   txtFile.Close
   ' si des erreurs surviennent pendant l'exportation, réinitialisez l'indicateur
   ' d'exportation réussie sur False
   If errMessage <> "" Then
       docObj.Action.Succeeded = False
       docObj.Action.ErrorMessage = errMessage
   EndIf
   Set txtFile = Nothing
   Set mFso = Nothing
ExitSub
err_h:
   docObj.Action.Succeeded = False
   docObj.Action.ErrorMessage = Err.Description
   txtFile.Close
   Set mFso = Nothing
EndSub
' Fonction d'exportation d'images. Si une erreur survient pendant l'exportation des images,
' un message relatif à l'erreur est retourné, sinon une chaîne vide est retournée
PrivateFunction exportImages(ByRef docObj As Object, ByRef FCTools As Object, _
   ByVal exportFolder AsString) AsString
OnErrorGoTo err_h
   Dim pages As Object, page As Object, imageOptions As Object
   Dim fileName AsString, pageNum AsLong
   exportImages = ""
   ' spécification des paramètres d'exportation
   Set imageOptions = FCTools.NewImageSavingOptions
   imageOptions.Format = "png"
   imageOptions.ColorType = "GrayScale"
   imageOptions.Resolution = 300
   ' exportation page par page
   Set pages = docObj.pages
   pageNum = 1
   ForEach page In pages
       fileName = mFso.BuildPath(exportFolder, page.definitionName + "_page" & pageNum & "." & imageOptions.Format)
       page.SaveAs fileName, imageOptions
       pageNum = pageNum + 1
   Next page
ExitFunction
err_h:
   exportImages = Err.Description
EndFunction
' Procédure d'exportation des informations concernant le document
PrivateSub exportDocInfo(ByRef docObj As Object, ByRef txtFile As TextStream)
OnErrorGoTo err_h
   txtFile.WriteLine "Doc info:"
   txtFile.WriteLine ("DocumentId " & docObj.Id)
   txtFile.WriteLine ("IsAssembled " & docObj.IsAssembled)
   txtFile.WriteLine ("IsVerified " & docObj.IsVerified)
   txtFile.WriteLine ("IsExported " & docObj.IsExported)
   txtFile.WriteLine ("ProcessingErrors " & docObj.ProcessingErrors)
   txtFile.WriteLine ("ProcessingWarnings " & docObj.ProcessingWarnings)
   txtFile.WriteLine ("TotalSymbolsCount " & docObj.TotalSymbolsCount)
   txtFile.WriteLine ("RecognizedSymbolsCount " & docObj.RecognizedSymbolsCount)
   txtFile.WriteLine ("UncertainSymbolsCount " & docObj.UncertainSymbolsCount)
   txtFile.WriteLine
ExitSub
err_h:
   txtFile.WriteLine Err.Description
EndSub
' Procédure d'exportation des champs à partir de l'ensemble de champs
PrivateFunction exportFields(ByRef fields As Object, ByRef txtFile As TextStream, ByVal indent As String) AsBoolean
OnErrorGoTo err_h
   Dim curField As Object
   exportFields = True
   ForEach curField In fields
       IfNot exportField(curField, txtFile, indent) Then
           exportFields = False
       EndIf
   Next curField
ExitFunction
err_h:
   txtFile.WriteLine Err.Description
   exportFields = False
EndFunction
' Vérifie si la valeur du champ est nulle
' Si la valeur du champ n'est pas valide, toute tentative d'accès à ce champ (y compris
' pour en vérifier la nullité) peut générer une exception
Function IsNullFieldValue(ByRef field As Object) AsBoolean
OnErrorGoTo err_h
   IsNullFieldValue = IsNull(field.Value)
ExitFunction
err_h:
   IsNullFieldValue = True
EndFunction
' Fonction d'exportation de champs
PrivateFunction exportField(ByRef field As Object, ByRef txtFile As TextStream, _
   ByVal indent AsString) AsBoolean
OnErrorGoTo err_h
   Dim result AsBoolean
   result = True
   ' enregistrement du nom des champs
   txtFile.Write (indent & field.Name)
   ' enregistrement de la valeur des champs accessibles
   IfNot IsNullFieldValue(field) Then
       txtFile.WriteLine ("    " & field.Value)
   Else
       txtFile.WriteLine
   EndIf
   IfNot field.Children Is NothingThen
       ' exportation des champs enfants
       result = result And exportFields(field.Children, txtFile, indent & "    ")
   ElseIfNot field.Items IsNothingThen
       ' exportation des instances de champs
       result = result And exportFields(field.Items, txtFile, indent & "    ")
   EndIf
   exportField = result
ExitFunction
err_h:
   txtFile.WriteLine Err.Description
   exportField = False
EndFunction
' La fonction crée un dossier d'exportation et retourne le chemin d'accès complet de ce dossier
PrivateFunction createExportFolder(ByVal definitionName AsString) AsString
OnErrorGoTo err_h
   Dim docFolder AsString, folderName AsString
   ' dossier principal
   Const exportFolder = "d:\AutomationExport"
   If mFso.FolderExists(exportFolder) = FalseThen
       mFso.CreateFolder (exportFolder)
   EndIf
   ' le dossier de la définition de document spécifiée
   docFolder = mFso.BuildPath(exportFolder, definitionName)
   If mFso.FolderExists(docFolder) = FalseThen
       mFso.CreateFolder (docFolder)
   EndIf
   ' dossier du document exporté
  Dim i AsLong
   i = 1
   folderName = mFso.BuildPath(docFolder, i)
   While mFso.FolderExists(folderName)
       i = i + 1
       folderName = mFso.BuildPath(docFolder, i)
   Wend
   mFso.CreateFolder (folderName)
   createExportFolder = folderName
ExitFunction
err_h:
   createExportFolder = ""
EndFunction

Utilisation d'un composant externe écrit en .Net ( C# )

Pour utiliser un composant externe écrit en .Net, procédez comme suit :

1. Créez un projet de type ClassLibrary
2. Ajoutez ControllerInterop.dll aux références du projet. ABBYY.FlexiCapture apparaît dans la liste Références et toutes les interfaces des objets de scripts sont désormais disponibles dans le projet.
3. Définissez l'interface disp et la classe implémentant cette interface, ainsi que ProgId (afin de pouvoir utiliser le composant .Net tout comme ActiveX, à partir du code du script).
4. Une fois que le projet est créé, enregistrez la bibliothèque de types générée (activez l'option correspondante dans les propriétés du projet pour effectuer cette opération automatiquement).
5. À partir du code d'exportation, appelez la méthode du composant comme vous le faites habvituellement :

[VBScript]
dim autoExport
set autoExport = CreateObject( "ExportLibrary1.Export" )
autoExport.ExportDocument me, FCTools
[JScript]
var autoExport = new ActiveXObject("ExportLibrary1.Export"); autoExport.ExportDocument( this, FCTools );

Le code d'un tel composant est illustré ci-dessous :

using System;
using System.Runtime.InteropServices;
using System.IO;
using ABBYY.FlexiCapture;
namespace ExportLibrary1
{
     // Interface du composant d'exportation accessible à partir du script
     // Lorsque vous créez un nouveau composant, générez un nouveau GUID
     [Guid("32B10C3B-EEA3-4194-B0A0-E358C310225A")]
     [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
     public interface _cExport
     {
           [DispId(1)]
           void ExportDocument(ref IExportDocument DocRef, ref FCTools Tools);
     }  
     // Classe implémentant la fonctionnalité du composant d'exportation
     // Lorsque vous créez un nouveau composant, générez un nouveau GUID
// et définissez votre ProgId
     [Guid("3BA19BD7-C6DC-4f63-BC08-0D95254DADC3")]
     [ClassInterface(ClassInterfaceType.None)]
     [ProgId("ExportLibrary1.Export")]
     [ComVisible(true)]
     public class Export : _cExport
     {
           public Export()
           {
           }
           // La fonction exécute l'exportation du document : elle crée un dossier d'exportation et
// enregistre dans ce dernier des fichiers image de pages,
// le fichier texte contenant les champs du document et des informations relatives au document
           public void ExportDocument( ref IExportDocument docRef, ref FCTools FCTools )
           {
                 try
                 {
                       string exportFolder = createExportFolder( docRef.DefinitionName );
                       exportImages( docRef, FCTools, exportFolder );
                       // création du fichier texte
                       string fileName = exportFolder + "//" + "doc.txt";
                       StreamWriter sw = File.CreateText( fileName );
                       // exportation des informations concernant le document
                       exportDocInfo( docRef, sw );
                       // exportation des champs
                       sw.WriteLine( "Fields:" );
                       exportFields( docRef.Children, sw, "" );
                       sw.Close();
                 }
                 catch( Exception e )
                 {
                       docRef.Action.Succeeded = false;
                       docRef.Action.ErrorMessage = e.ToString();                      
                 }
           }
           // La fonction crée un dossier d'exportation et retourne le chemin d'accès complet de ce dossier
           privatestring createExportFolder(string definitionName )
           {
                 string docFolder, folderName;
                 // dossier principal
                 string exportFolder = "d:\\DotNetExport";
                 if( !Directory.Exists(exportFolder) )
                 {
                       Directory.CreateDirectory(exportFolder);
                 }
                 // le dossier de la définition de document spécifiée
                 docFolder = exportFolder + "\\" + definitionName;
                 if( !Directory.Exists(docFolder) )
                 {
                       Directory.CreateDirectory( docFolder );
                 }
                 // dossier du document exporté
                 int i = 1;
                 folderName = docFolder + "\\" + i;
                 while( Directory.Exists(folderName) )
                 {
                       i++;
                       folderName = docFolder + "\\" + i;
                 }
                 Directory.CreateDirectory(folderName);
                 return folderName;
           }
           // Fonction d'exportation d'images
           private void exportImages( IExportDocument docRef, FCTools FCTools, string exportFolder )
           {
                 string baseFileName = exportFolder + "\\page_";
                 IExportImageSavingOptions imageOptions = FCTools.NewImageSavingOptions();
                 imageOptions.Format = "bmp";
                 imageOptions.ColorType = "FullColor";
                 imageOptions.Resolution = 100;
                 int i = 1;
                 foreach( IExportPage curPage in docRef.Pages )
                 {
                       string fileName = baseFileName + i + ".bmp";
                       curPage.SaveAs( fileName, imageOptions );
                       i++;
                 }
           }
           // Exportation des informations concernant le document
           private void exportDocInfo( IExportDocument docRef, StreamWriter sw )
           {
                 sw.WriteLine( "Doc info:" );
                 sw.WriteLine("DocumentId " + docRef.Id );
                 sw.WriteLine("IsAssembled " + docRef.IsAssembled);
                 sw.WriteLine("IsVerified " + docRef.IsVerified);
                 sw.WriteLine("IsExported " + docRef.IsExported);
                 sw.WriteLine("ProcessingErrors " + docRef.ProcessingErrors);
                 sw.WriteLine("ProcessingWarnings " + docRef.ProcessingWarnings);
                 sw.WriteLine("TotalSymbolsCount " + docRef.TotalSymbolsCount);
                 sw.WriteLine("RecognizedSymbolsCount " + docRef.RecognizedSymbolsCount);
                 sw.WriteLine("UncertainSymbolsCount " + docRef.UncertainSymbolsCount);
                 sw.WriteLine();
           }
           // Exportation d'un ensemble de champs
            private void exportFields( IExportFields fields, StreamWriter sw, string indent )
           {
                 foreach( IExportField curField in fields )
                 {
                       exportField( curField, sw, indent );
                 }
           }
           // Vérifie si la valeur du champ est nulle
           // Si la valeur du champ n'est pas valide, toute tentative d'accès à ce champ (y compris
// pour en vérifier la nullité) peut générer une exception
           privatebool IsNullFieldValue( IExportField field )
           {
                 try
                 {
                       return ( field.Value == null );
                 }
                 catch( Exception e )
                 {
                       returntrue;
                 }
           }
           // Exportation du champ spécifié
           private void exportField( IExportField field, StreamWriter sw, string indent )
           {
                 // enregistrement du nom des champs
                 sw.Write( indent + field.Name );
                 // enregistrement de la valeur des champs accessibles
                 if( IsNullFieldValue( field ) )
                 {
                       sw.WriteLine();
                 }
                 else
                 {
                       sw.WriteLine( "    " + field.Text );
                 }
                 if( field.Children != null )
                 {
                       // exportation des champs enfants
                       exportFields( field.Children, sw, indent + "    " );
                 }
                 else if( field.Items != null )
                 {
                       // exportation des instances de champs
                       exportFields( field.Items, sw, indent + "    " );
                 }
                 }
     }
           }

Cet exemple de code illustre un gestionnaire d'exportation élémentaire qui enregistre des informations concernant les documents exportés et exporte les résultats vers des fichiers texte. Deux fichiers texte sont utilisés dans cet exemple : l'un d'eux contient la liste des documents exportés avec succès et l'autre contient la liste des documents pour lesquels des erreurs ont été retournées pendant l'exportation.

[VBScript]
dim curDoc
dim fso, fileErrorName, txtErrorFile, fileSucceedName, txtSucceedFile
set fso = CreateObject("Scripting.FileSystemObject")
' création du fichier pour les documents dont l'exportation a échoué
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )
' création du fichier pour les documents dont l'exportation a réussi
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo
' itération de l'ensemble de documents exportés
for i = 0 Tome.Count - 1
   set exportResult = me.Item(i)
   docInfo = "DocumentId:" & exportResult.Document.Id
   if exportResult.Succeeded then
       docInfo = docInfo & " - Exported successfully."
       txtSucceedFile.WriteLine docInfo
   else
       docInfo = docInfo & " - Export error: " & exportResult.ErrorMessage
       txtErrorFile.WriteLine docInfo
   endif
next
txtErrorFile.Close
txtSucceedFile.Close
[JScript]
var fso = new ActiveXObject("Scripting.FileSystemObject");
// création des fichiers pour les documents dont l'exportation a échoués
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );
// création du fichier pour les documents dont l'exportation a réussi
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i
// itération de l'ensemble de documents exportés
for( i = 0; i < Documents.Count; i++ ) {
   var curDoc = Documents.Item( i );
   var docInfo = "DocumentId: " + curDoc.Id;
  if( curDoc.Action.Succeeded ) {
       docInfo = docInfo + ". Exported successfully.  Result:" + curDoc.Action.Result;
       txtSucceedFile.WriteLine( docInfo );
   } else {
       docInfo = docInfo + ". Export error: " + curDoc.Action.ErrorMessage + "  Result:" + curDoc.Action.Result;
       txtErrorFile.WriteLine( docInfo );
   }
}
txtErrorFile.Close();
txtSucceedFile.Close();

Cet exemple de script montre comment vous pouvez enregistrer les fichiers source lors de l'exportation de documents. Les fichiers source doivent être dans l’un des formats Office courants pris en charge et un nom unique doit leur être attribué afin d’éviter les conflits de noms.

using System;
using System.IO;
using System.Collections.Generic;
// Répéter sur toutes les pages.
for( int i = 0; i<Document.Pages.Count; i++ ) {
   IPage page = Document.Pages[i];
   // Vérifier la présence d'un fichier source.
   if( page.SourceFileGUID == "" ) {
       continue;
   }
  // Le nom d'origine du fichier.
   string sourceFileName = @"";
   // Spécifier le nom d'origine du fichier
   if( page.ImageSourceType == @"File" ) {
       sourceFileName = Path.GetFileName( page.ImageSource );
   } else if( page.ImageSourceType == @"Scanner" || page.ImageSourceType == @"Custom" ) {
       sourceFileName = Path.GetFileName( page.ImageSourceFileSubPath );
   }
   // Supprimer l'extension de fichier du nom du fichier.
   if( sourceFileName != @"" ) {
       sourceFileName = Path.GetFileNameWithoutExtension( sourceFileName ) + @".";
   }
  // Nom unique du fichier source (nom d'origine + guid).
   string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;
  // Le chemin d'accès au dossier dans lequel le fichier source doit être enregistré.
   string sourceFilePath = Document.Batch.Project.ExportRootPath + @"\" + sourceFileUniqueName;
  // S'assurer que le fichier n'existe pas.
   if( File.Exists( sourceFilePath ) ) {
       continue;
   }
  // Enregistrer le fichier.
   Processing.ReportMessage( "Enregistrement du fichier source : " + sourceFileUniqueName );
   page.SaveSourceFile( sourceFilePath );
}