Zum Hauptinhalt springen

Documentation Index

Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt

Use this file to discover all available pages before exploring further.

Die Schnittstellen von ABBYY FineReader Engine-Objekten verfügen über verschiedene Eigenschaften und Methoden. Im Allgemeinen enthalten Eigenschaften Informationen über ein Objekt, während Methoden Aktionen darstellen, die ein Objekt ausführen kann.
C#-Beispiele gelten für Windows. C++-Beispiele gelten für alle unterstützten Betriebssysteme.
Für C++ ist eine Eigenschaft ein Methodenpaar (get und put für Lese-/Schreibeigenschaften) oder eine einzelne get-Methode (für Eigenschaften, die nur lesbar sind).Die Eigenschaften von ABBYY FineReader Engine können die folgenden Typen haben:
  • VARIANT_BOOL (mit den beiden Werten VARIANT_TRUE oder VARIANT_FALSE)
  • int
  • double
  • BSTR, ein Zeiger auf eine Unicode-Zeichenfolge. Der Nullwert steht für eine leere Zeichenfolge.
  • __int64
  • HANDLE*
  • Von IUnknown abgeleitete Schnittstelle
  • enum
C#- und Visual Basic-Benutzer sind mit dem Konzept von Eigenschaften vertraut.Für einen C++-Benutzer ist eine Eigenschaft ein Methodenpaar (get und put für Lese-/Schreibeigenschaften) oder eine einzelne get-Methode (für Eigenschaften, die nur lesbar sind).Die von Microsoft C++ bereitgestellte Funktion „Native COM-Unterstützung“ sorgt jedoch dafür, dass Eigenschaften eher so behandelt werden wie in C#.Die Eigenschaften von ABBYY FineReader Engine können die folgenden Typen haben:
IDLC++C#Visual Basic .NET
VARIANT_BOOL (VARIANT_TRUE oder VARIANT_FALSE)VARIANT_BOOL (VARIANT_TRUE oder VARIANT_FALSE)bool (true oder false)Boolean (True oder False)
intintintInteger
doubledoubledoubleDouble
BSTR, ein Zeiger auf eine Unicode-Zeichenfolge. Der Nullwert steht für eine leere Zeichenfolge.BSTRstringString
__int64__int64Int64Int64
HANDLE*void*IntPtrIntPtr
Von IUnknown abgeleitete SchnittstelleVon IUnknown abgeleitete SchnittstelleobjectObject
enumenumenumEnum
Im Folgenden finden Sie Details zur Arbeit mit verschiedenen Eigenschaftstypen:
Anhand einer booleschen Eigenschaft zeigen wir, wie einfache Eigenschaften verwendet werden. Die Eigenschaft wird in der Typbibliothek wie folgt beschrieben:
interface IMyObject : IUnknown
{
  [propget]
  HRESULT MyProperty( [out, retval] VARIANT_BOOL* result );
  [propput]
  HRESULT MyProperty( [in] VARIANT_BOOL value );
};
Wenn die Typbibliothek für eine einfache Eigenschaft nur die Methode „get“ definiert, wird diese Eigenschaft als nur lesbar bezeichnet. Ihr Wert kann vom Benutzer nicht geändert werden; es kann nur lesend darauf zugegriffen werden.Ein C#-Benutzer arbeitet mit einer einfachen Eigenschaft wie folgt:
if (MyObject.MyProperty != true)
 MyObject.MyProperty = true;
Ein C++-Benutzer hingegen verwendet zwei Methoden, um mit dieser Eigenschaft zu arbeiten. Diese Methoden haben die Präfixe get_ und put_. Der entsprechende C++-Code sollte wie folgt aussehen:
IMyObject* pMyObject;
VARIANT_BOOL res;
pMyObject->get_MyProperty(&res);
if( res != VARIANT_TRUE )
   pMyObject->put_MyProperty(VARIANT_TRUE);
Die Native COM-Unterstützung in Windows vereinfacht das Verfahren jedoch, und der entsprechende Code sollte wie folgt aussehen:
IMyObjectPtr pMyObject;
if(pMyObject->MyProperty != VARIANT_TRUE)
   pMyObject->MyProperty = VARIANT_TRUE
Das Arbeiten mit String-Eigenschaften ähnelt dem Arbeiten mit einfachen Eigenschaften, weist jedoch eigene Besonderheiten auf. Ein C++-Entwickler, der mit String-Eigenschaften arbeitet, muss die Strings freigeben, die an Set-Methoden übergeben werden, sowie jene, die von Get-Methoden zurückgegeben werden.
  • Unter Windows geschieht dies automatisch in C#, Visual Basic und in C++ mit nativer COM-Unterstützung.
  • Unter Linux verwenden Sie die Funktionen FREngineAllocString und FREngineFreeString, um den Speicher für die Strings zu reservieren und freizugeben.
Angenommen, MyObject unterstützt auch eine String-Eigenschaft namens Name. Diese Eigenschaft wird in der Typbibliothek wie folgt beschrieben:
interface IMyObject : IUnknown
{
  [propget]
  HRESULT Name([out, retval]BSTR* result);
  [propput]
  HRESULT Name([in]BSTR value);
};
Ein C++-Entwickler arbeitet mit dieser Eigenschaft wie folgt:Windows
IMyObject* pMyObject;
// "get"-Methode
BSTR res;
pMyObject->get_Name(&res);
// Jetzt den in ABBYY FineReader Engine reservierten String freigeben
::SysFreeString(res);
// "put"-Methode
BSTR str = ::SysAllocString(L"New Name");
pMyObject->put_Name(str);
// Jetzt den selbst reservierten String freigeben
::SysFreeString(str);
Linux
IMyObject* pMyObject;
// "get"-Methode
BSTR res;
pMyObject->get_Name(&res);
// Jetzt den in ABBYY FineReader Engine reservierten String freigeben
::FREngineFreeString(res);
// "put"-Methode
BSTR str = ::FREngineAllocString(L"New Name");
pMyObject->put_Name(str);
// Jetzt den selbst reservierten String freigeben
::FREngineFreeString(str);
Ein C++-Entwickler wird feststellen, dass die Parameter der „get”-Methoden von Objekteigenschaften Zeiger auf den Interface-Zeiger eines Objekts sind. Da die Interfaces der Objekte von IUnknown abgeleitet sind, können sie als IUnknown-Zeiger an Eigenschaften oder Methoden übergeben werden, die Objekte mehrerer Typen als Ein- oder Ausgabeparameter verwenden (das benötigte Interface lässt sich jedoch durch Aufruf der QueryInterface-Methode abrufen).Eine „put”-Methode für eine Objekteigenschaft, sofern vorhanden, unterstützt Clear Put, das durch das Schlüsselwort propput in der Typbibliothek beschrieben wird. Das bedeutet, dass das Objekt kopiert wird, anstatt einen Zeiger auf das Interface eines vorhandenen Objekts zu übergeben.Angenommen, das Objekt MyObject unterstützt die Eigenschaft MyObjectProperty, die auf ein Objekt vom Typ MyChildObject verweist.
interface IMyObject : IUnknown
{
  [propget]
  HRESULT MyObjectProperty([out, retval]IMyChildObject** result);
  [propput]
  HRESULT MyObjectProperty([in]IMyChildObject* value);
};
Ein C++-Entwickler schreibt diesen Code wie folgt:
IMyObject* pMyObject;
IMyChildObject* pChildObj=0;
// get_-Methode kann in bestimmten Fällen 0 zurückgeben
pMyObject->get_MyObjectProperty(&pChildObj);
// Etwas mit dem Objekt tun
...
pMyObject->put_MyObjectProperty(pChildObj);
pChildObj->Release();
Beachten Sie, dass Sie in C++ die Release-Methode für ein über eine Eigenschaft erhaltenes Objekt aufrufen müssen. Die native COM-Unterstützung unter Windows ruft die Methoden AddRef und Release automatisch mithilfe von Auto-Zeigern auf.

Arbeiten mit nur lesbaren Objekteigenschaften

Bestimmte Objekte in ABBYY FineReader Engine (zum Beispiel ILayout::Blocks) haben nur lesbare Objekteigenschaften. Das bedeutet nicht, dass solche Eigenschaften nicht geändert werden können, sondern nur, dass sie nicht geändert werden können, indem die Objekteigenschaft direkt durch ein anderes Objekt ersetzt wird, da die “put”-Methode nicht unterstützt wird. Die Untereigenschaften dieser Objekte können Sie jedoch ändern. Wenn Sie in C++ (natives C++ unter Windows) eine solche Eigenschaft ändern möchten, müssen Sie eine Referenz auf das Eigenschaftsobjekt an eine neue Variable übergeben und diese Variable dann zum Ändern verwenden. Unten sehen Sie ein C++-Beispiel für die Eigenschaft ILayout::Blocks, die als nur lesbare Sammlung dargestellt wird:
// Wir gehen davon aus, dass eine Seite bereits geöffnet wurde
ILayout* pLayout = 0;
ILayoutBlocks* pLayoutBlocks = 0;
int blockIndex = 0;
// Layout von der zuvor geöffneten FRPage abrufen
pFRPage->get_Layout( &pLayout );
// Die Variable pLayoutBlocks erhält einen Verweis auf die Blocks-Sammlung aus dem Layout
pLayout->get_Blocks( &pLayoutBlocks );
// Ein Element aus der Block-Sammlung entfernen
pLayoutBlocks->DeleteAt( blockIndex );
// Mit dem geänderten Layout arbeiten
...
// Objekte freigeben
pLayoutBlocks->Release();
pLayout->Release();