Sample scripts describing export

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

[VBScript]
Dim field1Value, field2Value
' Gets the value of Field1 in Section 1
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
    field1Value = me.Field( "Section 1\Field1" ).Value
end if
' Gets the value of Field2 in Group1 in Section 1
if Not IsNull( me.FIELD( "Section 1\Group1\Field2" ).Value ) then
    field2Value = me.Field( "Section 1\Group1\Field2" ).Value
end if
' Gets the value of Field1 in Section 1 if the section has multiple 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]
// Gets the value of Field1 in Section 1
if( Field("Section 1\\Field1").Value != null ) {
var field1Value = Field("Section 1\\Field1").Value;
}
// Gets the value of Field2 in Group1 in Section 1
if( Field("Section 1\\Group1\\Field2").Value != null ) {
var field2Value = Field("Section 1\\Group1\\Field2").Value;
}
// Gets the value of Field1 in Section 1 if the section has multiple 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
    ' Sets the desired name and extension for the file depending on the selected format
    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++ ) {
    // Sets the desired name and extension for the file depending on the selected format
    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]
' The procedure carries out the export: creates an export folder and
' saves in it page image files, the text file with the document fields,
' and information about the document
Sub ExportDocument(ByRef docObj, ByRef FCTools)
    Dim folderName
    Dim txtFile, fileName
    Dim fso
    On Error Resume Next
    set fso = CreateObject("Scripting.FileSystemObject")
    ' creating the export folder
    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
    ' exporting images
    ExportImages docObj, FCTools, folderName, fso
    if Err.Number <> 0 then
        docObj.Action.Succeeded = false
        docObj.Action.ErrorMessage = "Error during export images: " + Err.Description
        Err.Clear
        Exit Sub
    End if
              ' creating the text file
    fileName = fso.BuildPath(folderName, "doc.txt")
    Set txtFile = fso.CreateTextFile(fileName, True)
    ' exporting info about the document
    ExportDocInfo docObj, txtFile
    ' exporting fields
    txtFile.WriteLine "Fields:"
    ExportFields docObj.Children, txtFile, ""
    txtFile.Close
    if Err.Number <> 0 then
        docObj.Action.Succeeded = false
        docObj.Action.ErrorMessage = "Error during export data: " + Err.Description
        Err.Clear
        Exit Sub
    End if
    Set txtFile = Nothing
    Set fso = Nothing
End Sub
' Image export function
Function ExportImages( ByRef docObj, ByRef FCTools, ByVal exportFolder, ByRef fso )
    Dim pages, page, imageOptions
    Dim fileName, pageNum
    ' specifying export settings
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "bmp"
    imageOptions.ColorType = "FullColor"
    imageOptions.Resolution = 100
    ' page-by-page export
    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
          ' The procedure that exports info about the 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
' The procedure that exports fields from the fields collection
Sub ExportFields(ByRef fields, ByRef txtFile, ByVal indent)
    Dim curField
    For Each curField In fields
        ExportField curField, txtFile, indent
    Next
End Sub
' Checks if the value of the fields is null
' If the field value is invalid, any attempt to access this field (even
' to check if it is null) may cause an 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
' Field export procedure
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)
    ' saving field name
    txtFile.Write (indent & field.Name)
    ' saving field value if it can be accessed
    If IsNullFieldValue(field) Then
        txtFile.WriteLine
    Else
        txtFile.WriteLine ("    " & field.Text)
    End If
    If Not field.Children Is Nothing Then
        ' exporting child fields
        ExportFields field.Children, txtFile, indent & "    "
    ElseIf Not field.Items Is Nothing Then
        ' exporting field instances
        ExportFields field.Items, txtFile, indent & "    "
    End If
End Sub
' The function creates an export folder and returns a full path to this folder
Function CreateExportFolder(ByVal definitionName, ByRef fso)
    Dim docFolder, folderName
    ' main folder
    exportFolder = "d:\ScriptExport"
    If fso.FolderExists(exportFolder) = False Then
        fso.CreateFolder (exportFolder)
    End If
    ' the folder of specified Document Definition
    docFolder = fso.BuildPath(exportFolder, definitionName)
    If fso.FolderExists(docFolder) = False Then
        fso.CreateFolder (docFolder)
    End If
    ' the folder of the exported document
    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]
// The function carries out the export: creates an export folder and
// saves in it page image files, the text file with the document fields,
// and information about the document
function ExportDocument(docObj, exportImageTools)
{
    var folderName
    var txtFile, fileName
    var fso
    fso = new ActiveXObject("Scripting.FileSystemObject");
    // creating export folders
    try {
        folderName = CreateExportFolder(docObj.DefinitionName, fso);
    } catch( e ) {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during create export folder: " + e.description;
        return;n;
    }
    // exporting images
    try {
        ExportImages(docObj, exportImageTools, folderName, fso);
    } catch( e ) {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during export images: " + e.description;
        return;
    }
    // creating the text file
    fileName = fso.BuildPath(folderName, "doc.txt");
    txtFile = fso.CreateTextFile(fileName, true);
    // exporting info about the document
    ExportDocInfo( docObj, txtFile );
    // exporting fields
    txtFile.WriteLine( "Fields:" );
    try {
        ExportFields( docObj.Children, txtFile, "" );
    } catch( e ) { {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during export data: " + e.description;
        txtFile.Close();
        return;
    }
    txtFile.Close();
    txtFile = 0;
    fso = 0;
}
// Image export function. 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 )
{
    // specifying export settings
    var imageOptions = exportImageTools.NewImageSavingOptions();
    imageOptions.Format = "bmp";
    imageOptions.ColorType = "FullColor";
    imageOptions.Resolution = 100;
    // page-by-page export
    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 );
    }
}
// The procedure that exports info about the 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();
}
// The procedure that exports fields from the fields collection
function ExportFields(fields, txtFile, indent)
{
    var i
    for( i = 0; i < fields.Count; i++ ) {
        ExportField( fields.Item(i), txtFile, indent );
    }
}
// Checks if the field value is null
// If the field value is invalid, any attempt to access this field (even
// to check if it is null) may cause an exception
function IsNullFieldValue( field )
{
    try {
        return ( field.Value == null );
    } catch( e ) {
        return true;
    }
}
// Field export procedure
function ExportField(field, txtFile, indent)
{
    // saving file name
    txtFile.Write(indent + field.Name);
    // saving field value, if it can be accessed
    if( IsNullFieldValue( field ) ) {
        txtFile.WriteLine();
    } else {
        txtFile.WriteLine("    " + field.Text);
    } }
    if( field.Children != null ) {
        // exporting child fields
        ExportFields( field.Children, txtFile, indent + "    " );
    } else if( field.Items != null ) {
        // exporting field instances
        ExportFields( field.Items, txtFile, indent + "    " );
    }
}
// The function creates an export folder and returns a full path to this folder
function CreateExportFolder(definitionName, fso)
{
    var docFolder, folderName
    // main folder
    var exportFolder = "d:\\ScriptExport";
    if( !fso.FolderExists(exportFolder) ) {
        fso.CreateFolder (exportFolder);
    } }
    // the folder of the specified Document Definition
    docFolder = fso.BuildPath(exportFolder, definitionName);
    if( !fso.FolderExists(docFolder) ) {
        fso.CreateFolder(docFolder);
    }
    // the folder of the exported document
    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
' The procedure carries out document export: created an export folder and
' saves in it page image files, the text file with document fields,
' and information about the 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
    ' creating export folder
    folderName = createExportFolder(docObj.definitionName)
    If folderName = "" Then
        docObj.Action.Succeeded = False
        docObj.Action.ErrorMessage = "Cannot create export folder"
        ExitSub
    EndIf
    ' exporting images
    imageExportResult = exportImages(docObj, FCTools, folderName)
    ' creating the text file
    fileName = mFso.BuildPath(folderName, "doc.txt")
    Set txtFile = mFso.CreateTextFile(fileName, True)
    ' saving info about image export problems
    If imageExportResult <> "" Then
        txtFile.WriteLine imageExportResult
        errMessage = errMessage & imageExportResult
    EndIf
    ' exporting info about document
    exportDocInfo docObj, txtFile
    ' exporting fields
    txtFile.WriteLine "Fields:"
    IfNot exportFields(docObj.Children, txtFile, "") Then
       errMessage = errMessage & " Error during export data"
    EndIf
    txtFile.Close
    ' if errors occur during export, reset the
    ' export success flag to 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
' Image export function. If an error occurs when exporting images,
' it returns a message about the error, otherwise it returns an empty string
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 = ""
    ' specifying export settings
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "png"
    imageOptions.ColorType = "GrayScale"
    imageOptions.Resolution = 300
    ' page-by-page export
    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
' The procedure that exports info about the 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
' The procedure that exports fields from the fields collection
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
' Checks if the field value is null
' If the value is invalid, any attempt to access this field (even
' to check if it is null) may cause an exception
Function IsNullFieldValue(ByRef field As Object) AsBoolean
OnErrorGoTo err_h
    IsNullFieldValue = IsNull(field.Value)
ExitFunction
err_h:
    IsNullFieldValue = True
EndFunction
' Field export function
PrivateFunction exportField(ByRef field As Object, ByRef txtFile As TextStream, _
    ByVal indent AsString) AsBoolean
OnErrorGoTo err_h
    Dim result AsBoolean
    result = True
    ' saving field name
    txtFile.Write (indent & field.Name)
    ' saving field value if it can be accessed
    IfNot IsNullFieldValue(field) Then
        txtFile.WriteLine ("    " & field.Value)
    Else
        txtFile.WriteLine
    EndIf
    IfNot field.Children Is NothingThen
        ' exporting child fields
        result = result And exportFields(field.Children, txtFile, indent & "    ")
    ElseIfNot field.Items IsNothingThen
        ' exporting field instances
        result = result And exportFields(field.Items, txtFile, indent & "    ")
    EndIf
    exportField = result
ExitFunction
err_h:
    txtFile.WriteLine Err.Description
    exportField = False
EndFunction
' The function creates an export folder and returns a full path to this folder
PrivateFunction createExportFolder(ByVal definitionName AsString) AsString
OnErrorGoTo err_h
    Dim docFolder AsString, folderName AsString
    ' main folder
    Const exportFolder = "d:\AutomationExport"
    If mFso.FolderExists(exportFolder) = FalseThen
        mFso.CreateFolder (exportFolder)
    EndIf
    ' the folder of the specified Document Definition
    docFolder = mFso.BuildPath(exportFolder, definitionName)
    If mFso.FolderExists(docFolder) = FalseThen
        mFso.CreateFolder (docFolder)
    EndIf
    ' the folder of the exported document
   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
{
                // The interface of the export component which can be accessed from the script
      // When creating a new component, generate a new GUID
      [Guid("32B10C3B-EEA3-4194-B0A0-E358C310225A")]
      [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
      public interface _cExport
      {
            [DispId(1)]
            void ExportDocument(ref IExportDocument DocRef, ref FCTools Tools);
      }   
      // The class that implements export component functionality
      // When creating a new component, generate a new GUID
// and set your ProgId
      [Guid("3BA19BD7-C6DC-4f63-BC08-0D95254DADC3")]
      [ClassInterface(ClassInterfaceType.None)]
      [ProgId("ExportLibrary1.Export")]
      [ComVisible(true)]
      public class Export : _cExport
      {
            public Export()
            {
            }
            // The function carries out document export: creates an export folder and
// saves in it page image files,
// the text file with document fields, and information about the document
            public void ExportDocument( ref IExportDocument docRef, ref FCTools FCTools )
            {
                  try
                  {
                        string exportFolder = createExportFolder( docRef.DefinitionName );
                        exportImages( docRef, FCTools, exportFolder );
                        // creating the text file
                        string fileName = exportFolder + "//" + "doc.txt";
                        StreamWriter sw = File.CreateText( fileName );
                        // exporting info about document
                        exportDocInfo( docRef, sw );
                        // exporting fields
                        sw.WriteLine( "Fields:" );
                        exportFields( docRef.Children, sw, "" );
                        sw.Close();
                  }
                  catch( Exception e )
                  {
                        docRef.Action.Succeeded = false;
                        docRef.Action.ErrorMessage = e.ToString();                      
                  }
            }
            // The function creates an export folder and returns a full path to this folder
            privatestring createExportFolder(string definitionName )
            {
                  string docFolder, folderName;
                  // main folder
                  string exportFolder = "d:\\DotNetExport";
                  if( !Directory.Exists(exportFolder) )
                  {
                        Directory.CreateDirectory(exportFolder);
                  }
                  // the folder of the specified Document Definition
                  docFolder = exportFolder + "\\" + definitionName;
                  if( !Directory.Exists(docFolder) )
                  {
                        Directory.CreateDirectory( docFolder ); 
                  }
                  // the folder of the exported document
                  int i = 1;
                  folderName = docFolder + "\\" + i;
                  while( Directory.Exists(folderName) )
                  {
                        i++;
                        folderName = docFolder + "\\" + i;
                  }
                  Directory.CreateDirectory(folderName);
                  return folderName;
            }
            // Image export function
            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++;
                  }
            }
            // Exporting info about 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();
            }
            // Exporting field collection
             private void exportFields( IExportFields fields, StreamWriter sw, string indent )
            {
                  foreach( IExportField curField in fields )
                  {
                        exportField( curField, sw, indent );
                  }
            }
            // Checks if the field value is null
            // If the field value is invalid, any attempt to access this field (even
// to check if it is null) may cause an exception
            privatebool IsNullFieldValue( IExportField field )
            {
                  try
                  {
                        return ( field.Value == null );
                  }
                  catch( Exception e )
                  {
                        returntrue;
                  }
            }
            // Exporting the specified field
            private void exportField( IExportField field, StreamWriter sw, string indent )
            {
                  // saving the field name
                  sw.Write( indent + field.Name );
                  // saving the field value if it can be accessed
                  if( IsNullFieldValue( field ) )
                  {
                        sw.WriteLine();
                  }
                  else
                  {
                        sw.WriteLine( "    " + field.Text );
                  }
                  if( field.Children != null )
                  {
                        // exporting child fields
                        exportFields( field.Children, sw, indent + "    " );
                  } 
                  else if( field.Items != null )
                  {
                        // exporting field instances
                        exportFields( field.Items, sw, indent + "    " );
                  }
                  }
      }
            }
        

[VBScript]
dim curDoc
dim fso, fileErrorName, txtErrorFile, fileSucceedName, txtSucceedFile
set fso = CreateObject("Scripting.FileSystemObject")
' creating the file with failed documents
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )
' creating the file with successfully exported documents
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo
' iterating the collection of exported documents
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");
// creating the file with failed documents
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );
// creating the file with successfully exported documents
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i
// iterating the collection of exported documents
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;
           
          // Iterate through the pages.
          for( int i = 0; i<Document.Pages.Count; i++ ) {
              IPage page = Document.Pages[i];
              // Check whether there is a source file.
              if( page.SourceFileGUID == "" ) {
                  continue;
              }
              // The original name of the file.
              string sourceFileName = @"";
              // Specify the original file name.
              if( page.ImageSourceType == @"File" ) {
                  sourceFileName = Path.GetFileName( page.ImageSource );
              } else if( page.ImageSourceType == @"Scanner" || page.ImageSourceType == @"Custom" ) {
                  sourceFileName = Path.GetFileName( page.ImageSourceFileSubPath );
              }
              // Remove the file extension from the file name.
              if( sourceFileName != @"" ) {
                  sourceFileName = Path.GetFileNameWithoutExtension( sourceFileName ) + @".";
              }
              // Unique source file name (original name + guid).
              string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;
              // The path to the folder where the source file must be saved.
              string sourceFilePath = Document.Batch.Project.ExportRootPath + @"\" + sourceFileUniqueName;
              // Make sure that the file does not exist.
              if( File.Exists( sourceFilePath ) ) {
                  continue;
              }
              // Save the file.
              Processing.ReportMessage( "Saving source file: " + sourceFileUniqueName );
              page.SaveSourceFile( sourceFilePath );
          }