Zum Hauptinhalt springen
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 support“ 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 );
};
if (MyObject.MyProperty != true)
 MyObject.MyProperty = true;
IMyObject* pMyObject;
VARIANT_BOOL res;
pMyObject->get_MyProperty(&res);
if( res != VARIANT_TRUE )
   pMyObject->put_MyProperty(VARIANT_TRUE);
IMyObjectPtr pMyObject;
if(pMyObject->MyProperty != VARIANT_TRUE)
   pMyObject->MyProperty = VARIANT_TRUE
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: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:Die Native COM-Unterstützung in Windows vereinfacht das Verfahren jedoch, und der entsprechende Code sollte wie folgt aussehen:
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);
};
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);
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 arbeitet mit dieser Eigenschaft wie folgt:Windows:Linux:
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);
};
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();
Ein C++-Entwickler schreibt diesen Code wie folgt: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++ (unter Windows in nativem C++) 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();