Pular para o conteúdo principal
As interfaces dos objetos do ABBYY FineReader Engine têm várias propriedades e métodos. Em geral, as propriedades representam informações sobre um objeto, enquanto os métodos representam ações que um objeto pode executar.
Os exemplos em C# se aplicam ao Windows. Os exemplos em C++ se aplicam a todos os sistemas operacionais compatíveis.
Para C++, uma propriedade é um par de métodos (get e put, no caso de propriedades de leitura e gravação) ou um único método get (no caso de propriedades somente leitura).As propriedades do ABBYY FineReader Engine podem ser dos seguintes tipos:
  • VARIANT_BOOL (com dois valores: VARIANT_TRUE ou VARIANT_FALSE)
  • int
  • double
  • BSTR, um ponteiro para string Unicode. O valor zero especifica uma string vazia.
  • __int64
  • HANDLE*
  • interface derivada de IUnknown
  • enum
Os usuários de C# e Visual Basic já estão familiarizados com o conceito de propriedade.Para um usuário de C++, uma propriedade é um par de métodos (get e put, no caso de propriedades de leitura e gravação) ou um único método get (no caso de propriedades somente leitura).No entanto, o recurso “suporte nativo a COM” do Microsoft C++ faz com que a forma de manipular propriedades seja mais parecida com a usada em C#.As propriedades do ABBYY FineReader Engine podem ser dos seguintes tipos:
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, um ponteiro para string Unicode. O valor zero especifica uma string vazia.BSTRstringString
__int64__int64Int64Int64
HANDLE*void*IntPtrIntPtr
interface derivada de IUnknowninterface derivada de IUnknownobjectObject
enumenumenumEnum
Veja abaixo os detalhes de como trabalhar com diferentes tipos de propriedades:
Usaremos uma propriedade booleana como exemplo de como propriedades simples são usadas. A propriedade é descrita na biblioteca de tipos da seguinte forma:
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
Se a biblioteca de tipos definir apenas o método “get” para uma propriedade simples, essa propriedade será chamada de somente leitura. Seu valor não pode ser alterado pelo usuário; ele só pode ser acessado para “leitura”.Um usuário de C# manipula uma propriedade simples da seguinte forma:Já um usuário de C++ usa dois métodos para trabalhar com essa propriedade. Esses métodos têm os prefixos get_ e put_. O respectivo código em C++ deve ser parecido com o seguinte:No entanto, o suporte nativo a COM no Windows simplifica o procedimento, e o respectivo código deve ser parecido com o seguinte:
Trabalhar com propriedades string é muito semelhante a trabalhar com propriedades simples, mas tem particularidades próprias. Um usuário de C++ que trabalha com propriedades string deve liberar as strings passadas aos métodos set, bem como as retornadas pelos métodos get.
  • No Windows, isso é feito automaticamente em C#, Visual Basic e em C++ com o suporte nativo a COM.
  • No Linux, use as funções FREngineAllocString e FREngineFreeString para alocar e liberar a memória das strings.
Suponha que MyObject também suporte uma propriedade string chamada Name. Essa propriedade é descrita na biblioteca de tipos da seguinte forma:
interface IMyObject : IUnknown
{
  [propget]
  HRESULT Name([out, retval]BSTR* result);
  [propput]
  HRESULT Name([in]BSTR value);
};
IMyObject* pMyObject;
// método "get"
BSTR res;
pMyObject->get_Name(&res);
// Agora libere a string alocada no ABBYY FineReader Engine
::SysFreeString(res);
// método "put"
BSTR str = ::SysAllocString(L"New Name");
pMyObject->put_Name(str);
// Agora libere a string que alocamos
::SysFreeString(str);
IMyObject* pMyObject;
// método "get"
BSTR res;
pMyObject->get_Name(&res);
// Agora libere a string alocada no ABBYY FineReader Engine
::FREngineFreeString(res);
// método "put"
BSTR str = ::FREngineAllocString(L"New Name");
pMyObject->put_Name(str);
// Agora libere a string que alocamos
::FREngineFreeString(str);
Um usuário de C++ trabalha com essa propriedade da seguinte forma:Windows:Linux:
Um usuário de C++ dirá que os parâmetros dos métodos “get” de propriedades de objeto são ponteiros para o ponteiro de interface de um objeto. Como as interfaces dos objetos derivam de IUnknown, elas podem ser passadas como ponteiros para IUnknown para propriedades ou métodos que usam objetos de vários tipos como parâmetros de entrada ou saída (no entanto, você pode obter a interface necessária chamando o método QueryInterface).Um método “put” para uma propriedade de objeto, se existir, oferece suporte à atribuição por cópia, descrita pela palavra-chave propput na biblioteca de tipos. Isso significa que o objeto é copiado (em vez de ser passado um ponteiro para a interface de um objeto existente).Suponha novamente que o objeto MyObject suporte a propriedade MyObjectProperty, que se refere a um objeto do tipo MyChildObject.
interface IMyObject : IUnknown
{
  [propget]
  HRESULT MyObjectProperty([out, retval]IMyChildObject** result);
  [propput]
  HRESULT MyObjectProperty([in]IMyChildObject* value);
};
IMyObject* pMyObject;
IMyChildObject* pChildObj=0;
// o método get_ pode retornar 0 em certos casos
pMyObject->get_MyObjectProperty(&pChildObj);
// Faça algo com o objeto
...
pMyObject->put_MyObjectProperty(pChildObj);
pChildObj->Release();
Um usuário de C++ escreverá esse código da seguinte forma:Observe que, em C++, você deve chamar o método Release para um objeto obtido por meio de uma propriedade. O suporte nativo a COM no Windows chama automaticamente os métodos AddRef e Release usando ponteiros automáticos.

​
Trabalhando com propriedades de objeto somente leitura

Alguns objetos do ABBYY FineReader Engine (por exemplo, ILayout::Blocks) têm propriedades de objeto somente leitura. Isso não significa que essas propriedades não possam ser alteradas; significa apenas que elas não podem ser alteradas substituindo diretamente a propriedade do objeto por outro objeto, porque o método “put” não é compatível. No entanto, você pode alterar as subpropriedades desses objetos. Em C++ (C++ nativo no Windows), se você quiser alterar esse tipo de propriedade, precisará atribuir uma referência ao objeto da propriedade a uma nova variável e, em seguida, usar essa variável para alterá-la. Abaixo, você pode ver um exemplo em C++ para a propriedade ILayout::Blocks, que é representada por uma coleção somente leitura: 
// Assumimos que uma página já foi aberta
ILayout* pLayout = 0;
ILayoutBlocks* pLayoutBlocks = 0;
int blockIndex = 0;
// Recebe o layout da FRPage aberta anteriormente
pFRPage->get_Layout( &pLayout );
// A variável pLayoutBlocks recebe uma referência à coleção de blocos do Layout
pLayout->get_Blocks( &pLayoutBlocks );
// Remove um elemento da coleção de blocos
pLayoutBlocks->DeleteAt( blockIndex );
// Trabalha com o layout modificado
...
// Libera os objetos
pLayoutBlocks->Release();
pLayout->Release();