Exemples de scripts décrivant une exportation

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;
                }
                      }
        }
    }
}
        

[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 );
}
        

[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();
        

[VBScript]
Export.ExportDocument me, FCTools

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

[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 );
          

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
          

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

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 + "    " );
                            }
                  }
      }
            }
        

[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();
        

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 );
          }