Recebendo entrada do controle de entrada matemática

Esta seção explica como recuperar a marcação MathML do controle de entrada matemática usando a ATL (Ative Template Library) e o COM (Component Object Model).

Para recuperar a equação matemática reconhecida do controle de entrada matemática, você pode substituir o comportamento que acontece quando o botão de inserção é pressionado. Para fazer isso, você precisará configurar um manipulador de eventos que implementa os vários eventos que são suportados pela interface _IMathInputControlEvents. A configuração do manipulador de eventos envolve a execução das seguintes etapas para os eventos aos quais você deseja oferecer suporte (inserir neste caso).

• Crie uma classe de modelo que contenha coletores de eventos
• Configurar os manipuladores de eventos
• Herdar a classe manipuladora de eventos na sua classe principal
• Inicialize sua classe para herdar o(s) coletor(es) de eventos

Criar uma classe de modelo que contenha receptores de eventos

Ao implementar um coletor de eventos que usa o controle de entrada matemática, você deve primeiro especificar uma ID de coletor. Em seguida, você deve criar uma classe de modelo que herda do evento, manipulador de controle de evento e interfaces de evento de controle de entrada matemática. O código a seguir mostra como definir um ID de coletor e criar uma classe de modelo, CMathInputControlEventHandler, que herda das interfaces necessárias. Esta classe de modelo também é configurada para ter um ponteiro de interface desconhecido privado que será usado para passar o controle de entrada matemática para ele na inicialização e o membro m_ulAdviseCount para contar o número de chamadas para aconselhar / desaconselhar.

  
#pragma once
static const int MATHINPUTCONTROL_SINK_ID = 1 ;

template <class T>
class ATL_NO_VTABLE CMathInputControlEventHandler :
    public IDispEventSimpleImpl<MATHINPUTCONTROL_SINK_ID, CMathInputControlEventHandler<T>, &__uuidof(_IMathInputControlEvents)>
{
private:
    IUnknown    *m_pUnknown;
    ULONG m_ulAdviseCount;
    CDialog *m_pMain;

Agora que você tem a classe de modelo básica, você deve fornecer uma declaração de encaminhamento para os manipuladores de eventos que você substituirá e, em seguida, deve configurar um mapa de coletor para os eventos que você estará manipulando. O código a seguir mostra como configurar manipuladores de eventos para o método Insert, chamado quando um usuário clica no botão inserir no controle de entrada matemática e o método Close, chamado quando um usuário clica no botão cancelar no controle de entrada matemática.

  
public:
    static const _ATL_FUNC_INFO OnMICInsertInfo; // = {CC_STDCALL, VT_I4, 1, {VT_BSTR}};
    static const _ATL_FUNC_INFO OnMICCloseInfo;  // = {CC_STDCALL, VT_I4, 0, {VT_EMPTY}};

    BEGIN_SINK_MAP(CMathInputControlEventHandler)
        SINK_ENTRY_INFO(MATHINPUTCONTROL_SINK_ID, __uuidof(_IMathInputControlEvents), DISPID_MICInsert, OnMICInsert, const_cast<_ATL_FUNC_INFO*>(&OnMICInsertInfo))
        SINK_ENTRY_INFO(MATHINPUTCONTROL_SINK_ID, __uuidof(_IMathInputControlEvents), DISPID_MICClose, OnMICClose, const_cast<_ATL_FUNC_INFO*>(&OnMICCloseInfo))  
    END_SINK_MAP()

Como você estará trabalhando com o controle de entrada matemática, será útil definir uma referência interna para a interface relevante. A seguinte função de utilitário é criada na classe de exemplo para definir essa referência.

    
  HRESULT Initialize(IUnknown *pUnknown, CDialog *pMain)
  {
    m_pMain  = pMain;
    m_pUnknown = pUnknown;
    m_ulAdviseCount = 0;
    return S_OK;
  }
  

Configurar os manipuladores de eventos

Depois de configurados os coletores de eventos, precisarás criar as tuas implementações dos coletores de eventos. Em ambos os métodos no exemplo de código a seguir, os coletores de eventos recuperam um identificador para a interface de controle de entrada matemática. Na função Inserir, o resultado do reconhecimento é exibido como MathML e o controle fica oculto. Na função Fechar, o controle de entrada matemática está oculto.

  
    // Methods
    HRESULT __stdcall OnMICInsert( BSTR bstrRecoResult)
    {
        CComQIPtr<IMathInputControl> spMIC(m_pUnknown);
        HRESULT hr=S_OK;
        if (spMIC)
        {           
            MessageBox(NULL,bstrRecoResult,L"Recognition Result",MB_OK);
            hr = spMIC->Hide();
            return hr;  
        }
        return E_FAIL;          
    }

    HRESULT __stdcall OnMICClose()
    {
        CComPtr<IMathInputControl> spMIC;
        HRESULT hr = m_pUnknown->QueryInterface<IMathInputControl>(&spMIC);
        if (SUCCEEDED(hr))
        {           
            hr = spMIC->Hide();
            return hr;  
        }
        return hr;                  
    }
};  

Herdar a classe do manipulador de eventos em sua classe principal

Depois de implementar sua classe de modelo, você precisará herdá-la para a classe na qual você configurará seu controle de entrada matemática. Para os fins deste guia, esta classe é uma caixa de diálogo, CMIC_TEST_EVENTSDlg. No cabeçalho da caixa de diálogo, os cabeçalhos necessários devem ser incluídos e a classe de modelo criada deve ser herdada. A classe que estás a herdar e os manipuladores de eventos devem ter declarações antecipadas para que o modelo possa ser implementado. O exemplo de código a seguir mostra como isso é feito.

#pragma once
#include <atlbase.h>
#include <atlwin.h>

// include for MIC
#include "micaut.h"

// include for event sinks
#include <iacom.h>
#include "mathinputcontroleventhandler.h"

class CMIC_TEST_EVENTSDlg;

const _ATL_FUNC_INFO CMathInputControlEventHandler<CMIC_TEST_EVENTSDlg>::OnMICInsertInfo = {CC_STDCALL, VT_I4, 1, {VT_BSTR}};
const _ATL_FUNC_INFO CMathInputControlEventHandler<CMIC_TEST_EVENTSDlg>::OnMICCloseInfo = {CC_STDCALL, VT_I4, 0, {VT_EMPTY}};

// CMIC_TEST_EVENTSDlg dialog
class CMIC_TEST_EVENTSDlg : public CDialog,
    public CMathInputControlEventHandler<CMIC_TEST_EVENTSDlg>
{
  public:
  CComPtr<IMathInputControl> m_spMIC; // Math Input Control

  

Inicialize sua classe para herdar o(s) coletor(es) de eventos

Depois de configurar sua classe para herdar da classe de modelo, você estará pronto para configurá-la para manipular eventos. Isso consistirá em inicializar a classe para obter uma referência ao controlo de entrada matemática e à classe que a invoca. Além disso, o controle de entrada matemática para lidar com eventos deve ser enviado ao método DispEventAdvise, que é herdado pela classe de exemplo CMathInputControlEventHandler. O código a seguir é chamado do método OnInitDialog na classe de exemplo para executar essas ações.

// includes for implementation
#include "micaut_i.c"

// include for event handler
#include "mathinputcontroleventhandler.h"

...

OnInitDialog{
  ...

  // TODO: Add extra initialization here
  CoInitialize(NULL);
  HRESULT hr = g_spMIC.CoCreateInstance(CLSID_MathInputControl);
  if (SUCCEEDED(hr)){
    hr = CMathInputControlEventHandler<CMIC_TEST_EVENTSDlg>::Initialize(m_spMIC, this);
      if (SUCCEEDED(hr)){
        hr = CMathInputControlEventHandler<CMIC_TEST_EVENTSDlg>::DispEventAdvise(m_spMIC);            
        if (SUCCEEDED(hr)){
          hr = m_spMIC->Show();  
        }
      }
    }
  }  
}