Beispielskripte für die Exportbeschreibung

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

[VBScript]
Dim field1Value, field2Value
' Ruft den Wert des Field1 in Abschnitt 1 ab
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
    field1Value = me.Field( "Section 1\Field1" ).Value
end if
' Ruft den Wert des Feld2 in Gruppe1 in Abschnitt 1 ab
if Not IsNull( me.FIELD( "Section 1\Group1\Field2" ).Value ) then
    field2Value = me.Field( "Section 1\Group1\Field2" ).Value
end if
' Ruft den Wert des Field1 in Abschnitt 1 ab, wenn der Abschnitt mehrere Instanzen enthält
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]
// Ruft den Wert des Field1 in Abschnitt 1 ab
if( Field("Section 1\\Field1").Value != null ) {
var field1Value = Field("Section 1\\Field1").Value;
}
// Ruft den Wert des Feld2 in Gruppe1 in Abschnitt 1 ab
if( Field("Section 1\\Group1\\Field2").Value != null ) {
var field2Value = Field("Section 1\\Group1\\Field2").Value;
}
// Ruft den Wert des Field1 in Abschnitt 1 ab, wenn der Abschnitt mehrere Instanzen enthält
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
    ' Legt den gewünschten Dateinamen und die Erweiterung in Abhängigkeit vom ausgewählten Format fest 
    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++ ) {
    // Legt den gewünschten Dateinamen und die Erweiterung in Abhängigkeit vom ausgewählten Format fest 
    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]
' Die Prozedur führt den Export durch: Sie erstellt einen Exportordner und
' speichert in ihm Seitenbilddateien, die Textdatei mit den Dokumentfeldern 
' und Informationen über das Dokument 
Sub ExportDocument(ByRef docObj, ByRef FCTools)
    Dim folderName
    Dim txtFile, fileName
    Dim fso
    On Error Resume Next
    set fso = CreateObject("Scripting.FileSystemObject")
    ' Erstellen des Exportordners 
    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
    ' Bilder exportieren 
    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
              ' Die Textdatei erstellen 
    fileName = fso.BuildPath(folderName, "doc.txt")
    Set txtFile = fso.CreateTextFile(fileName, True)
    ' Informationen über das Dokument exportieren 
    ExportDocInfo docObj, txtFile
    ' Felder exportieren 
    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
' Bildexportfunktion 
Function ExportImages( ByRef docObj, ByRef FCTools, ByVal exportFolder, ByRef fso )
    Dim pages, page, imageOptions
    Dim fileName, pageNum
    ' Spezifizierung der Exporteinstellungen 
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "bmp"
    imageOptions.ColorType = "FullColor"
    imageOptions.Resolution = 100
    ' Seitenweiser 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
          ' Prozedur zum Exportieren der Informationen über das Dokument 
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
' Prozedur zum Exportieren von Feldern aus der Auflistung von Feldern 
Sub ExportFields(ByRef fields, ByRef txtFile, ByVal indent)
    Dim curField
    For Each curField In fields
        ExportField curField, txtFile, indent
    Next
End Sub
' Überprüft, ob der Wert des Felds NULL ist 
' Wenn der Feldwert ungültig ist, dann kann jeder Zugriffsversuch (auch 
' die Überprüfung auf NULL) kann eine Ausnahme auslösen 
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
' Feldexportprozedur
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)
    ' Feldnamen speichern 
    txtFile.Write (indent & field.Name)
    ' Feldwert, sofern verfügbar, speichern 
    If IsNullFieldValue(field) Then
        txtFile.WriteLine
    Else
        txtFile.WriteLine ("    " & field.Text)
    End If
    If Not field.Children Is Nothing Then
        ' untergeordnete Felder exportieren 
        ExportFields field.Children, txtFile, indent & "    "
    ElseIf Not field.Items Is Nothing Then
        ' Feldinstanzen exportieren 
        ExportFields field.Items, txtFile, indent & "    "
    End If
End Sub
' Die Funktion erstellt einen Exportordner und gibt seinen vollständigen Pfad zurück
Function CreateExportFolder(ByVal definitionName, ByRef fso)
    Dim docFolder, folderName
    ' Hauptordner 
    exportFolder = "d:\ScriptExport"
    If fso.FolderExists(exportFolder) = False Then
        fso.CreateFolder (exportFolder)
    End If
    ' der Ordner der spezifizierten Dokumentdefinition 
    docFolder = fso.BuildPath(exportFolder, definitionName)
    If fso.FolderExists(docFolder) = False Then
        fso.CreateFolder (docFolder)
    End If
    ' der Ordner für das exportierte Dokument 
    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]
// Die Prozedur führt den Export durch: Sie erstellt einen Exportordner und 
// speichert in ihm Seitenbilddateien, die Textdatei mit den Dokumentfeldern
// und Informationen über das Dokument 
function ExportDocument(docObj, exportImageTools)
{
    var folderName
    var txtFile, fileName
    var fso
    fso = new ActiveXObject("Scripting.FileSystemObject");
    // Erstellen des Exportordners 
    try {
        folderName = CreateExportFolder(docObj.DefinitionName, fso);
    } catch( e ) {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during create export folder: " + e.description;
        return;n;
    }
    // Bilder exportieren
    try {
        ExportImages(docObj, exportImageTools, folderName, fso);
    } catch( e ) {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during export images: " + e.description;
        return;
    }
    // Die Textdatei erstellen 
    fileName = fso.BuildPath(folderName, "doc.txt");
    txtFile = fso.CreateTextFile(fileName, true);
    // Informationen über das Dokument exportieren
    ExportDocInfo( docObj, txtFile );
    // Felder exportieren 
    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;
}
// Bildexportfunktion. Wenn während des Bildexports ein Fehler auftritt, 
// dann wird eine Meldung über den Fehler zurückgegeben, andernfalls eine leere Zeichenfolge 
function ExportImages( docObj, exportImageTools, exportFolder, fso )
{
    // Spezifizierung der Exporteinstellungen 
    var imageOptions = exportImageTools.NewImageSavingOptions();
    imageOptions.Format = "bmp";
    imageOptions.ColorType = "FullColor";
    imageOptions.Resolution = 100;
    // Seitenweiser 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 );
    }
}
// Prozedur zum Exportieren der Informationen über das Dokument 
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();
}
// Prozedur zum Exportieren von Feldern aus der Auflistung von Feldern 
function ExportFields(fields, txtFile, indent)
{
    var i
    for( i = 0; i < fields.Count; i++ ) {
        ExportField( fields.Item(i), txtFile, indent );
    }
}
// Überprüft, ob der Wert des Felds NULL ist 
// Wenn der Feldwert ungültig ist, dann kann jeder Zugriffsversuch (auch 
// die Überprüfung auf NULL) eine Ausnahme auslösen 
function IsNullFieldValue( field )
{
    try {
        return ( field.Value == null );
    } catch( e ) {
        return true;
    }
}
// Feldexportprozedur 
function ExportField(field, txtFile, indent)
{
    // Feldnamen speichern 
    txtFile.Write(indent + field.Name);
    // Feldwert, sofern verfügbar, speichern 
    if( IsNullFieldValue( field ) ) {
        txtFile.WriteLine();
    } else {
        txtFile.WriteLine("    " + field.Text);
    } }
    if( field.Children != null ) {
        // untergeordnete Felder exportieren 
        ExportFields( field.Children, txtFile, indent + "    " );
    } else if( field.Items != null ) {
        // Export von Feldinstanzen 
        ExportFields( field.Items, txtFile, indent + "    " );
    }
}
// Die Funktion erstellt einen Exportordner und gibt seinen vollständigen Pfad zurück 
function CreateExportFolder(definitionName, fso)
{
    var docFolder, folderName
    // Hauptordner 
    var exportFolder = "d:\\ScriptExport";
    if( !fso.FolderExists(exportFolder) ) {
        fso.CreateFolder (exportFolder);
    } }
    // der Ordner der spezifizierten Dokumentdefinition 
    docFolder = fso.BuildPath(exportFolder, definitionName);
    if( !fso.FolderExists(docFolder) ) {
        fso.CreateFolder(docFolder);
    }
    // der Ordner für das exportierte Dokument 
    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 );
          

ExpliziteOption 
Dim mFso AsNew Scripting.FileSystemObject
' Die Prozedur führt den Export durch: Sie erstellt einen Exportordner und 
' speichert in ihm Seitenbilddateien, die Textdatei mit den Dokumentfeldern 
' und Informationen über das Dokument 
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
    ' Exportordner erstellen 
    folderName = createExportFolder(docObj.definitionName)
    If folderName = "" Then
        docObj.Action.Succeeded = False
        docObj.Action.ErrorMessage = "Cannot create export folder"
        ExitSub
    EndIf
    ' Bilder exportieren 
    imageExportResult = exportImages(docObj, FCTools, folderName)
    ' Die Textdatei erstellen 
    fileName = mFso.BuildPath(folderName, "doc.txt")
    Set txtFile = mFso.CreateTextFile(fileName, True)
    Informationen über Probleme beim Bildexport speichern 
    If imageExportResult <> "" Then
        txtFile.WriteLine imageExportResult
        errMessage = errMessage & imageExportResult
    EndIf
    ' Informationen über das Dokument exportieren 
    exportDocInfo docObj, txtFile
    ' Felder exportieren 
    txtFile.WriteLine "Fields:"
    IfNot exportFields(docObj.Children, txtFile, "") Then
       errMessage = errMessage & " Error during export data"
    EndIf
    txtFile.Close
    ' Wenn Fehler während des Exports auftreten, 
    ' das Flag für erfolgreichen Export auf False zurücksetzen 
    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
' Bildexportfunktion. Wenn während des Bildexports ein Fehler auftritt, 
' dann wird eine Meldung über den Fehler zurückgegeben, andernfalls eine leere Zeichenfolge 
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 = ""
    ' Spezifizierung der Exporteinstellungen 
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "png"
    imageOptions.ColorType = "GrayScale"
    imageOptions.Resolution = 300
    ' Seitenweiser 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
' Prozedur zum Exportieren der Informationen über das Dokument 
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
' Prozedur zum Exportieren von Feldern aus der Auflistung von Feldern 
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
' Überprüft, ob der Wert des Felds NULL ist 
' Wenn der Feldwert ungültig ist, dann kann jeder Zugriffsversuch (auch 
' die Überprüfung auf NULL) eine Ausnahme auslösen 
Function IsNullFieldValue(ByRef field As Object) AsBoolean
OnErrorGoTo err_h
    IsNullFieldValue = IsNull(field.Value)
ExitFunction
err_h:
    IsNullFieldValue = True
EndFunction
' Feldexportfunktion 
PrivateFunction exportField(ByRef field As Object, ByRef txtFile As TextStream, _
    ByVal indent AsString) AsBoolean
OnErrorGoTo err_h
    Dim result AsBoolean
    result = True
    ' Feldnamen speichern 
    txtFile.Write (indent & field.Name)
    ' Feldwert, sofern verfügbar, speichern 
    IfNot IsNullFieldValue(field) Then
        txtFile.WriteLine ("    " & field.Value)
    Else
        txtFile.WriteLine
    EndIf
    IfNot field.Children Is NothingThen
        ' untergeordnete Felder exportieren 
        result = result And exportFields(field.Children, txtFile, indent & "    ")
    ElseIfNot field.Items IsNothingThen
        ' Feldinstanzen exportieren 
        result = result And exportFields(field.Items, txtFile, indent & "    ")
    EndIf
    exportField = result
ExitFunction
err_h:
    txtFile.WriteLine Err.Description
    exportField = False
EndFunction
' Die Funktion erstellt einen Exportordner und gibt seinen vollständigen Pfad zurück 
PrivateFunction createExportFolder(ByVal definitionName AsString) AsString
OnErrorGoTo err_h
    Dim docFolder AsString, folderName AsString
    ' Hauptordner 
    Const exportFolder = "d:\AutomationExport"
    If mFso.FolderExists(exportFolder) = FalseThen
        mFso.CreateFolder (exportFolder)
    EndIf
    ' der Ordner der spezifizierten Dokumentdefinition 
    docFolder = mFso.BuildPath(exportFolder, definitionName)
    If mFso.FolderExists(docFolder) = FalseThen
        mFso.CreateFolder (docFolder)
    EndIf
    ' Ordner für das exportierte Dokument 
   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
{
                // Die Schnittstelle der Exportkomponente, auf die vom Skript aus zugegriffen werden kann
      // Beim Erstellen einer neuen Komponente eine neue GUID erstellen
      [Guid("32B10C3B-EEA3-4194-B0A0-E358C310225A")]
      [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
      public interface _cExport
      {
            [DispId(1)]
            void ExportDocument(ref IExportDocument DocRef, ref FCTools Tools);
      }   
      // Die Klasse, die die Funktion der Exportkomponente implementiert
      // Beim Erstellen einer neuen Komponente eine neue GUID erstellen 
// und Ihre ProgId festlegen 
      [Guid("3BA19BD7-C6DC-4f63-BC08-0D95254DADC3")]
      [ClassInterface(ClassInterfaceType.None)]
      [ProgId("ExportLibrary1.Export")]
      [ComVisible(true)]
      public class Export : _cExport
      {
            public Export()
            {
            }
            // Die Prozedur führt den Export durch: Sie erstellt einen Exportordner und 
// speichert in ihm Seitenbilddateien, 
// die Textdatei mit Dokumentfeldern und Informationen über das Dokument 
            public void ExportDocument( ref IExportDocument docRef, ref FCTools FCTools )
            {
                  try
                  {
                        string exportFolder = createExportFolder( docRef.DefinitionName );
                        exportImages( docRef, FCTools, exportFolder );
                        // Die Textdatei erstellen
                        string fileName = exportFolder + "//" + "doc.txt";
                        StreamWriter sw = File.CreateText( fileName );
                        // Informationen über das Dokument exportieren
                        exportDocInfo( docRef, sw );
                        // Felder exportieren
                        sw.WriteLine( "Fields:" );
                        exportFields( docRef.Children, sw, "" );
                        sw.Close();
                  }
                  catch( Exception e )
                  {
                        docRef.Action.Succeeded = false;
                        docRef.Action.ErrorMessage = e.ToString();                      
                  }
            }
            // Die Funktion erstellt einen Exportordner und gibt seinen vollständigen Pfad zurück
            privatestring createExportFolder(string definitionName )
            {
                  string docFolder, folderName;
                  // Hauptordner
                  string exportFolder = "d:\\DotNetExport";
                  if( !Directory.Exists(exportFolder) )
                  {
                        Directory.CreateDirectory(exportFolder);
                  }
                  // der Ordner der spezifizierten Dokumentdefinition
                  docFolder = exportFolder + "\\" + definitionName;
                  if( !Directory.Exists(docFolder) )
                  {
                        Directory.CreateDirectory( docFolder ); 
                  }
                  // Ordner für das exportierte Dokument
                  int i = 1;
                  folderName = docFolder + "\\" + i;
                  while( Directory.Exists(folderName) )
                  {
                        i++;
                        folderName = docFolder + "\\" + i;
                  }
                  Directory.CreateDirectory(folderName);
                  return folderName;
            }
            // Bildexportfunktion
            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++;
                  }
            }
            // Informationen über das Dokument exportieren
            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();
            }
            // Auflistung von Feldern exportieren
             private void exportFields( IExportFields fields, StreamWriter sw, string indent )
            {
                  foreach( IExportField curField in fields )
                  {
                        exportField( curField, sw, indent );
                  }
            }
            // Überprüft, ob der Wert des Felds Null ist
            // Wenn der Feldwert ungültig ist, dann kann jeder Zugriffsversuch (auch 
// die Überprüfung auf NULL) eine Ausnahme auslösen 
            privatebool IsNullFieldValue( IExportField field )
            {
                  try
                  {
                        return ( field.Value == null );
                  }
                  catch( Exception e )
                  {
                        returntrue;
                  }
            }
            // Angegebenes Feld exportieren
            private void exportField( IExportField field, StreamWriter sw, string indent )
            {
                  // Angegebenes Feld exportieren
                  sw.Write( indent + field.Name );
                  // Feldwert, sofern verfügbar, speichern
                  if( IsNullFieldValue( field ) )
                  {
                        sw.WriteLine();
                  }
                  else
                  {
                        sw.WriteLine( "    " + field.Text );
                  }
                  if( field.Children != null )
                  {
                        // untergeordnete Felder exportieren
                        exportFields( field.Children, sw, indent + "    " );
                  } 
                  else if( field.Items != null )
                  {
                        // Feldinstanzen exportieren
                        exportFields( field.Items, sw, indent + "    " );
                  }
                  }
      }
            }
        

[VBScript]
dim curDoc
dim fso, fileErrorName, txtErrorFile, fileSucceedName, txtSucceedFile
set fso = CreateObject("Scripting.FileSystemObject")
' Datei mit der Liste fehlgeschlagener Dokumente erstellen 
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )
' Datei mit der Liste erfolgreich exportierter Dokumente erstellen 
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo
' Auflistung der exportierten Dokumente durchlaufen 
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");
// Datei mit der Liste fehlgeschlagener Dokumente erstellen 
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );
// Datei mit der Liste erfolgreich exportierter Dokumente erstellen 
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i
// Auflistung der exportierten Dokumente durchlaufen 
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;
           
          // Blättern Sie durch die Seiten.
          for( int i = 0; i<Document.Pages.Count; i++ ) {
              IPage page = Document.Pages[i];
              // Prüfen Sie, ob eine Quelldatei vorhanden ist.
              if( page.SourceFileGUID == "" ) {
                  continue;
              }
              // Der ursprüngliche Name der Datei.
              string sourceFileName = @"";
              // Ursprünglichen Dateinamen angeben.
              if( page.ImageSourceType == @"File" ) {
                  sourceFileName = Path.GetFileName( page.ImageSource );
              } else if( page.ImageSourceType == @"Scanner" || page.ImageSourceType == @"Custom" ) {
                  sourceFileName = Path.GetFileName( page.ImageSourceFileSubPath );
              }
              // Entfernen der Dateierweiterung aus dem Dateinamen.
              if( sourceFileName != @"" ) {
                  sourceFileName = Path.GetFileNameWithoutExtension( sourceFileName ) + @".";
              }
              // Eindeutiger Name der Quelldatei (ursprünglicher Name + guid).
              string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;
              // Der Pfad zu dem Ordner, in dem die Quelldatei gespeichert werden muss.
              string sourceFilePath = Document.Batch.Project.ExportRootPath + @"\" + sourceFileUniqueName;
              // Die Datei darf nicht enthalten sein.
              if( File.Exists( sourceFilePath ) ) {
                  continue;
              }
              // Speichern Sie die Datei.
              Processing.ReportMessage( "Saving source file: " + sourceFileUniqueName );
              page.SaveSourceFile( sourceFilePath );
          }