Passer au contenu principal
Les interfaces des objets ABBYY FineReader Engine comportent diverses propriétés et méthodes. En règle générale, les propriétés représentent des informations sur un objet, tandis que les méthodes correspondent aux actions qu’un objet peut effectuer.
Les exemples en C# s’appliquent à Windows. Les exemples en C++ s’appliquent à tous les systèmes d’exploitation pris en charge.
En C++, une propriété est constituée d’une paire de méthodes (get et put pour les propriétés en lecture-écriture) ou d’une seule méthode get (pour les propriétés en lecture seule).Les propriétés d’ABBYY FineReader Engine peuvent être des types suivants :
  • VARIANT_BOOL (avec deux valeurs, VARIANT_TRUE ou VARIANT_FALSE)
  • int
  • double
  • BSTR, un pointeur vers une string Unicode. La valeur zéro indique une string vide.
  • __int64
  • HANDLE*
  • interface dérivée de IUnknown
  • enum
Les utilisateurs de C# et de Visual Basic connaissent bien la notion de propriété.Pour un utilisateur C++, une propriété est constituée d’une paire de méthodes (get et put pour les propriétés en lecture-écriture) ou d’une seule méthode get (pour les propriétés en lecture seule).Cependant, la fonctionnalité “Native COM support” de Microsoft C++ rend la gestion des propriétés plus proche de celle utilisée en C#.Les propriétés d’ABBYY FineReader Engine peuvent être des types suivants :
IDLC++C#Visual Basic .NET
VARIANT_BOOL (VARIANT_TRUE ou VARIANT_FALSE)VARIANT_BOOL (VARIANT_TRUE ou VARIANT_FALSE)bool (true ou false)Boolean (True ou False)
intintintInteger
doubledoubledoubleDouble
BSTR, un pointeur vers une string Unicode. La valeur zéro indique une string vide.BSTRstringString
__int64__int64Int64Int64
HANDLE*void*IntPtrIntPtr
interface dérivée de IUnknowninterface dérivée de IUnknownobjectObject
enumenumenumEnum
Voir ci-dessous les détails relatifs à l’utilisation des différents types de propriétés :
Nous prendrons une propriété booléenne comme exemple pour montrer comment les propriétés simples sont utilisées. La propriété est décrite dans la bibliothèque de types comme suit :
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
Si la bibliothèque de types définit uniquement la méthode “get” pour une propriété simple, cette propriété est dite en lecture seule. Sa valeur ne peut pas être modifiée par l’utilisateur et peut uniquement être consultée en “lecture”.Un utilisateur C# manipule une propriété simple comme suit :Un utilisateur C++, en revanche, utilise deux méthodes pour travailler avec cette propriété. Ces méthodes portent les préfixes get_ et put_. Le code C++ correspondant doit se présenter comme suit :Cependant, la fonctionnalité Native COM support sous Windows simplifie la procédure, et le code correspondant doit se présenter comme suit :
L’utilisation des propriétés string est très similaire à celle des propriétés simples, mais présente quelques particularités. En C++, l’utilisateur qui manipule des propriétés string doit libérer les chaînes passées aux méthodes set, ainsi que celles renvoyées par les méthodes get.
  • Sous Windows, cela se fait automatiquement en C#, en Visual Basic et en C++ avec le Native COM support.
  • Sous Linux, utilisez les fonctions FREngineAllocString et FREngineFreeString pour allouer et libérer la mémoire des chaînes.
Supposons que MyObject prenne également en charge une propriété string appelée Name. Cette propriété est décrite dans la bibliothèque de types comme suit :
interface IMyObject : IUnknown
{
  [propget]
  HRESULT Name([out, retval]BSTR* result);
  [propput]
  HRESULT Name([in]BSTR value);
};
IMyObject* pMyObject;
// méthode "get"
BSTR res;
pMyObject->get_Name(&res);
// Libérez maintenant la chaîne allouée dans ABBYY FineReader Engine
::SysFreeString(res);
// méthode "put"
BSTR str = ::SysAllocString(L"New Name");
pMyObject->put_Name(str);
// Libérez maintenant la chaîne que nous avons allouée
::SysFreeString(str);
IMyObject* pMyObject;
// méthode "get"
BSTR res;
pMyObject->get_Name(&res);
// Libérez maintenant la chaîne allouée dans ABBYY FineReader Engine
::FREngineFreeString(res);
// méthode "put"
BSTR str = ::FREngineAllocString(L"New Name");
pMyObject->put_Name(str);
// Libérez maintenant la chaîne que nous avons allouée
::FREngineFreeString(str);
En C++, cette propriété s’utilise comme suit :Windows :Linux :
En C++, on dira que les paramètres des méthodes “get” des propriétés d’objet sont des pointeurs vers un pointeur d’interface d’objet. Comme les interfaces des objets dérivent de IUnknown, elles peuvent être transmises sous forme de pointeurs IUnknown aux propriétés ou méthodes qui utilisent des objets de plusieurs types comme paramètres d’entrée ou de sortie (vous pouvez toutefois obtenir l’interface dont vous avez besoin en appelant la méthode QueryInterface).S’il existe une méthode “put” pour une propriété d’objet, elle prend en charge le clear put, décrit par le mot-clé propput dans la bibliothèque de types. Cela signifie que l’objet est copié (au lieu de transmettre un pointeur vers l’interface d’un objet existant).Supposons de nouveau que l’objet MyObject prenne en charge la propriété MyObjectProperty, qui fait référence à un objet de type MyChildObject.
interface IMyObject : IUnknown
{
  [propget]
  HRESULT MyObjectProperty([out, retval]IMyChildObject** result);
  [propput]
  HRESULT MyObjectProperty([in]IMyChildObject* value);
};
IMyObject* pMyObject;
IMyChildObject* pChildObj=0;
// la méthode get_ peut renvoyer 0 dans certains cas
pMyObject->get_MyObjectProperty(&pChildObj);
// Faire quelque chose avec l’objet
...
pMyObject->put_MyObjectProperty(pChildObj);
pChildObj->Release();
En C++, ce code s’écrit comme suit :Notez qu’en C++, vous devez appeler la méthode Release pour un objet obtenu via une propriété. Le Native COM support sous Windows appelle automatiquement les méthodes AddRef et Release à l’aide de pointeurs automatiques.

Utilisation des propriétés d’objet en lecture seule

Certains objets ABBYY FineReader Engine (par exemple, ILayout::Blocks) ont des propriétés d’objet en lecture seule. Cela ne signifie pas que ces propriétés ne peuvent pas être modifiées, mais seulement qu’elles ne peuvent pas l’être en remplaçant directement la propriété d’objet par un autre objet, car la méthode “put” n’est pas prise en charge. En revanche, vous pouvez modifier les sous-propriétés de ces objets. En C++ (C++ natif sous Windows), si vous souhaitez modifier une telle propriété, vous devez affecter une référence à l’objet de propriété à une nouvelle variable, puis utiliser cette variable pour la modifier. Vous trouverez ci-dessous un exemple en C++ pour la propriété ILayout::Blocks, qui est représentée par une collection en lecture seule :
// Nous supposons qu'une page a déjà été ouverte
ILayout* pLayout = 0;
ILayoutBlocks* pLayoutBlocks = 0;
int blockIndex = 0;
// Récupérer le layout depuis la FRPage précédemment ouverte
pFRPage->get_Layout( &pLayout );
// La variable pLayoutBlocks reçoit une référence à la collection de blocs depuis le Layout
pLayout->get_Blocks( &pLayoutBlocks );
// Supprimer un élément de la collection de blocs
pLayoutBlocks->DeleteAt( blockIndex );
// Travailler avec le layout modifié
...
// Libérer les objets
pLayoutBlocks->Release();
pLayout->Release();