Compartir a través de

Recepción de la entrada del control de entrada matemática

  • Artículo

En esta sección se explica cómo recuperar el marcado MathML del control de entrada matemática mediante la biblioteca de plantillas activas (ATL) y el modelo de objetos componentes (COM).

Para recuperar la ecuación matemática reconocida del control de entrada matemática, puede invalidar el comportamiento que se produce cuando se presiona el botón de inserción. Para ello, deberá configurar un controlador de eventos que implemente los distintos eventos admitidos por la interfaz _IMathInputControlEvents . La configuración del controlador de eventos implica realizar los pasos siguientes para los eventos que desea admitir (inserte en este caso).

Crear una clase de plantilla que contenga receptores de eventos

Al implementar un receptor de eventos que usa el control de entrada matemática, primero debe especificar un identificador de receptor. A continuación, debe crear una clase de plantilla que herede del evento, el controlador de control de eventos y las interfaces de eventos de control de entrada matemática. En el código siguiente se muestra cómo establecer un identificador de receptor y crear dicha clase de plantilla, CMathInputControlEventHandler, que hereda de las interfaces necesarias. Esta clase de plantilla también está configurada para tener un puntero de interfaz desconocido privado que se usará para pasarle el control de entrada matemática en la inicialización y el miembro de m_ulAdviseCount para contar el número de llamadas para avisar o anular la desviación.

  
#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;

Nota

El miembro m_pMain debe ser diferente en la implementación si no usa un cuadro de diálogo.

 

Ahora que tiene la clase de plantilla básica, debe proporcionar una declaración de reenvío para los controladores de eventos que va a invalidar y, a continuación, debe configurar un mapa de receptor para los eventos que va a controlar. En el código siguiente se muestra cómo configurar controladores de eventos para el método Insert , al que se llama cuando un usuario hace clic en el botón insertar del control de entrada matemática y el método Close , al que se llama cuando un usuario hace clic en el botón Cancelar del control 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()

Puesto que va a trabajar con el control de entrada matemática, será útil establecer una referencia interna a la interfaz pertinente. La siguiente función de utilidad se crea en la clase de ejemplo para establecer esta referencia.

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

Configurar los controladores de eventos

Una vez configurados los receptores de eventos, deberá crear las implementaciones de los receptores de eventos. En ambos métodos del ejemplo de código siguiente, los receptores de eventos recuperan un identificador de la interfaz de control de entrada matemática. En la función Insert , el resultado del reconocimiento se muestra como MathML y el control está oculto. En la función Close , el control 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;                  
    }
};

Heredar la clase del controlador de eventos en la clase principal

Una vez implementada la clase de plantilla, deberá heredarla en la clase en la que configurará el control de entrada matemática. Para los fines de esta guía, esta clase es un cuadro de diálogo, CMIC_TEST_EVENTSDlg. En el encabezado del cuadro de diálogo, se deben incluir los encabezados necesarios y se debe heredar la clase de plantilla que creó. La clase que hereda dentro de y los controladores de eventos deben tener declaraciones de reenvío para que se pueda implementar la plantilla. En el ejemplo de código siguiente se muestra cómo se hace esto.

#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

Nota

El tipo de plantilla, CMIC_TEST_EventsDlg, será diferente a menos que haya llamado a la clase igual que el ejemplo.

 

Inicialice la clase para heredar los receptores de eventos.

Una vez que haya configurado la clase para heredar de la clase de plantilla, estará listo para configurarla para controlar los eventos. Esto constará de inicializar la clase para que tenga un identificador para el control de entrada matemática y la clase que realiza la llamada. Además, el control de entrada matemática para controlar eventos de debe enviarse al método DispEventAdvise que hereda la clase de ejemplo CMathInputControlEventHandler. Se llama al código siguiente desde el método OnInitDialog de la clase de ejemplo para realizar estas acciones.

// 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();  
        }
      }
    }
  }  
}

Nota

El tipo de plantilla, CMIC_TEST_EventsDlg en este ejemplo, será diferente a menos que haya llamado a la clase igual que el ejemplo.