Beispielskripte für die Exportbeschreibung

Dieser Beispielcode veranschaulicht, wie Sie den Wert eines Felds beim Export abrufen. Sie können mit diesem Wert die Dateien benennen, in die die Bilder oder Daten exportiert werden. Ist kein entsprechendes Feld im Dokument enthalten, tritt ein Fehler auf.

Die Struktur des in diesem Beispiel exportierten Dokuments sieht wie folgt aus:

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

Anhand des Codes in diesem Beispiel wird das Exportieren von Bildern aller Dokumentseiten mit dem erforderlichen Dateiformat, dem Farbschema und der Auflösung veranschaulicht. Die Bilder werden seitenweise gespeichert, so dass jede Seite in einer eigenen Datei gespeichert wird.

Die Dateien in diesem Beispiel werden mit "page1.tif", "page2.tif" usw. bezeichnet, Sie können das Benennungsschema für die Dateien aber ggf. ändern, indem Sie beispielsweise die Dateinamen auf Grundlage des Werts eines Felds erstellen.

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

In diesem Beispiel wird das Exportieren einer Tabelle in eine TXT-Datei veranschaulicht.

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

Dieses Beispiel zeigt, wie Felder eines Dokuments mit beliebiger Verschachtelungstiefe mithilfe benutzerdefinierter Funktionen aus dem globalen Exportmodul exportiert werden. Wenn Sie Dokumentfelder mit variabler Verschachtelung exportieren möchten, sollten Sie eine externe COM-Komponente verwenden. (Weitere Informationen finden Sie im nächsten Beispiel.)

Kerncode für den Export

[VBScript]
Export.ExportDocument me, FCTools

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

Der Code der Funktionen des globalen Exportmoduls

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

Code einer ActiveX-Komponente in VisualBasic

Im Folgenden sehen Sie Code einer Exporter-Klasse aus dem Projekt "AutomationExport", das bereits in den oben beschriebenen Skripten verwendet wurde.

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

Verwenden einer externen Komponente, die in .Net (C#) geschrieben ist

So verwenden Sie eine externe Komponente, die in .Net (C#) geschrieben ist:

1. Erstellen Sie ein Projekt des Typs ClassLibrary.
2. Fügen Sie die ControllerInterop.dll zu den Referenzen des Projekts hinzu. ABBYY FlexiCapture wird in der Liste References aufgeführt, und alle Schnittstellen der Skriptobjekte werden im Projekt verfügbar.
3. Definieren Sie die Schnittstelle disp und die Klasse, die diese Schnittstelle implementiert, sowie ProgId (dadurch wird es möglich, im Code des Skripts mit der .Net-Komponente so zu arbeiten wie mit ActiveX).
4. Registrieren Sie nach dem Aufbau des Projekts die Library der generierten Typen (das kann auch automatisch durch das Aktivieren der entsprechenden Option in den Projekteigenschaften erfolgen).
5. Rufen Sie vom Exportcode aus die Methode der Komponente auf die übliche Weise auf:

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

Below follows the code of such a component:

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

Dieser Beispielcode zeigt eine einfache Exportsteuerung, die Informationen über die exportierten Dokumente und Exportergebnisse in Textdateien speichert. In diesem Beispiel werden zwei Textdateien verwendet: Eine Datei enthält die Liste der erfolgreich exportierten Dokumente und die andere die Liste der Dokumente, bei denen während des Exports Fehler aufgetreten sind.

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

Dieses Beispielskript zeigt, wie Sie die Quelldateien beim Exportieren von Dokumenten speichern können. Die Quelldateien müssen in einem der unterstützten gebräuchlichen Office-Formate vorliegen und müssen eindeutige Namen haben, damit Namenskonflikte vermieden werden.

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