Odbieranie danych wejściowych z kontrolki wprowadzania danych matematycznych

W tej sekcji wyjaśniono, jak pobrać znaczniki MathML z kontrolki danych wejściowych matematycznych przy użyciu biblioteki Active Template Library (ATL) i modelu obiektów składowych (COM).

Aby pobrać rozpoznane równanie matematyczne z kontrolki wprowadzania matematycznego, można zastąpić zachowanie, które ma miejsce po naciśnięciu przycisku 'Wstaw'. W tym celu należy skonfigurować program obsługi zdarzeń, który implementuje różne zdarzenia obsługiwane przez interfejs _IMathInputControlEvents. Skonfigurowanie programu obsługi zdarzeń obejmuje wykonanie następujących kroków dla zdarzeń, które mają być obsługiwane (wstaw w tym przypadku).

• Utwórz klasę szablonową zawierającą odbiorniki zdarzeń
• Konfigurowanie procedur obsługi zdarzeń
• Dziedzicz klasę obsługi zdarzeń w głównej klasie
• zainicjować klasę, aby dziedziczyć ujścia zdarzeń

Utwórz klasę szablonu zawierającą odbiorniki zdarzeń

Podczas implementowania ujścia zdarzeń używającego kontrolki danych wejściowych matematycznych należy najpierw określić identyfikator ujścia. Następnie należy utworzyć klasę szablonu dziedziczą po zdarzeniu, procedurze obsługi sterowania zdarzeniami i interfejsach zdarzeń kontroli danych wejściowych matematycznych. Poniższy kod pokazuje, jak ustawić identyfikator ujścia i utworzyć taką klasę szablonu CMathInputControlEventHandler, która dziedziczy z wymaganych interfejsów. Ta klasa szablonu jest również skonfigurowana tak, aby miała prywatny, nieznany wskaźnik interfejsu, który będzie używany do przekazywania do niej kontrolki matematycznej podczas inicjalizacji oraz składową m_ulAdviseCount w celu zliczenia liczby wywołań funkcji do powiadamiania i wycofywania powiadomienia.

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

Teraz, gdy masz podstawową klasę szablonu, musisz podać wstępną deklarację dla programów obsługi zdarzeń, które zamierzasz nadpisać, a następnie należy skonfigurować mapę sink dla zdarzeń, które będą obsługiwane. Poniższy kod pokazuje, jak skonfigurować programy obsługi zdarzeń dla metody Insert wywoływanej, gdy użytkownik kliknie przycisk wstawiania w kontrolce danych wejściowych matematycznych, a metoda Zamknij wywoływana, gdy użytkownik kliknie przycisk anuluj w kontrolce danych wejściowych matematycznych.

  
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()

Ponieważ będziesz pracować z kontrolką danych wejściowych matematycznych, warto ustawić wewnętrzne odwołanie do odpowiedniego interfejsu. Następująca funkcja użytkowa jest tworzona w klasie przykładowej, aby ustawić to odwołanie.

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

Konfigurowanie programów obsługi zdarzeń

Gdy już skonfigurujesz odbiorniki zdarzeń, musisz utworzyć ich implementacje. W obu metodach w poniższym przykładzie kodu odbiorniki zdarzeń pobierają uchwyt do interfejsu kontrolki wprowadzania danych matematycznych. W funkcji Insert wynik rozpoznawania jest wyświetlany jako MathML, a kontrolka jest ukryta. W funkcji Close kontrolka danych wejściowych matematycznych jest ukryta.

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

Rozszerz klasę obsługi zdarzeń w swojej głównej klasie

Po zaimplementowaniu klasy szablonu należy ją odziedziczyć do klasy, w której zostanie skonfigurowana kontrolka danych wejściowych matematycznych. Na potrzeby tego przewodnika ta klasa jest dialogiem, CMIC_TEST_EVENTSDlg. W nagłówku okna dialogowego należy uwzględnić wymagane nagłówki, a klasa szablonu, którą utworzyłeś, musi zostać odziedziczona. Klasa, która jest dziedziczona, oraz procedury obsługi zdarzeń muszą zawierać deklaracje wstępne, aby można było zaimplementować szablon. W poniższym przykładzie kodu pokazano, jak to zrobić.

#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

  

Zainicjuj swoją klasę, aby dziedziczyć odbiorniki zdarzeń

Po skonfigurowaniu klasy do dziedziczenia z klasy szablonu możesz przystąpić do konfigurowania jej w celu obsługi zdarzeń. To polega na zainicjowaniu klasy tak, aby miała uchwyt do kontrolki wejściowej danych matematycznych oraz klasy wywołującej. Ponadto kontrolka wprowadzania matematycznego do obsługi zdarzeń musi być wysyłana do metody DispEventAdvise, którą dziedziczy przykładowa klasa CMathInputControlEventHandler. Poniższy kod jest wywoływany z metody OnInitDialog w przykładowej klasie w celu wykonania tych akcji.

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