Invoer ontvangen van de invoercontrole voor wiskundige invoer

In deze sectie wordt uitgelegd hoe u de MathML-markeringen ophaalt uit het besturingselement voor wiskundige invoer met behulp van de Active Template Library (ATL) en het Component Object Model (COM).

Als u de herkende wiskundige vergelijking wilt ophalen uit het besturingselement voor wiskundige invoer, kunt u het gedrag overschrijven dat gebeurt wanneer de invoegknop wordt ingedrukt. Hiervoor moet u een gebeurtenis-handler instellen waarmee de verschillende gebeurtenissen worden geïmplementeerd die worden ondersteund door de _IMathInputControlEvents-interface. Het instellen van de gebeurtenis-handler omvat de volgende stappen voor de gebeurtenissen die u wilt ondersteunen (in dit geval invoegen).

• Een sjabloonklasse maken die gebeurtenissinks bevat
• de gebeurtenis-handlers instellen
• De gebeurtenishandlerklasse overnemen in uw hoofdklasse
• initialiseer uw klasse om de gebeurtenissink(en) over te nemen

Een sjabloonklasse maken die gebeurtenissinks bevat

Wanneer u een gebeurtenissink implementeert die gebruikmaakt van het besturingselement voor wiskundige invoer, moet u eerst een sink-id opgeven. Vervolgens moet u een sjabloonklasse maken die overgaat van de gebeurtenis, gebeurtenisbeheerhandler en gebeurtenisinterfaces voor wiskundige invoerbeheer. De volgende code laat zien hoe u een sink-id instelt en een dergelijke sjabloonklasse, CMathInputControlEventHandler, maakt die wordt overgenomen van de vereiste interfaces. Deze sjabloonklasse is ook ingesteld om een persoonlijke onbekende interfaceaanwijzer te hebben die wordt gebruikt om het besturingselement voor wiskundige invoer aan de sjabloon door te geven bij initialisatie en het m_ulAdviseCount lid om het aantal aanroepen te tellen dat moet worden geadviseerd/niet-goedgekeurd.

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

Nu u de basissjabloonklasse hebt, moet u een forward declaration geven voor de event-handlers die u wilt implementeren en daarna een sink-map instellen voor de gebeurtenissen die u gaat verwerken. De volgende code laat zien hoe u gebeurtenis-handlers instelt voor de methode Invoegen, aangeroepen wanneer een gebruiker op de Invoegen-knop in het besturingselement voor wiskundige invoer klikt, en de methode Sluiten, aangeroepen wanneer een gebruiker op de Annuleren-knop in het besturingselement voor wiskundige invoer klikt.

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

Omdat u met het besturingselement voor wiskundige invoer werkt, is het handig om een interne verwijzing naar de relevante interface in te stellen. De volgende hulpprogrammafunctie wordt gemaakt in de voorbeeldklasse om deze verwijzing in te stellen.

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

De gebeurtenishandlers instellen

Zodra u de gebeurtenissinks instelt, dient u uw eigen implementaties voor de gebeurtenissinks te creëren. In beide methoden in het volgende codevoorbeeld halen de gebeurtenissinks een ingang op voor de interface voor rekeninvoerbesturing. In de functie Invoegen wordt het herkenningsresultaat weergegeven als MathML en is het besturingselement verborgen. In de functie Close is het besturingselement voor wiskundige invoer verborgen.

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

Erf de event handler class in uw hoofdklasse.

Nadat u de sjabloonklasse hebt geïmplementeerd, moet u deze overnemen in de klasse waarin u het besturingselement voor wiskundige invoer gaat instellen. Voor deze handleiding is deze klasse een dialoogvenster, CMIC_TEST_EVENTSDlg. In de dialoogvensterkop moeten de vereiste headers worden opgenomen en moet de sjabloonklasse die u hebt gemaakt, worden overgenomen. De klasse waarvan u erft en de event handlers moeten forwarddeclaraties hebben, zodat de sjabloon kan worden geïmplementeerd. In het volgende codevoorbeeld ziet u hoe dit wordt gedaan.

#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

  

Initialiseer uw klasse om de gebeurtenissink(en) over te nemen

Zodra u uw klasse hebt ingesteld om over te nemen van de sjabloonklasse, kunt u deze instellen voor het afhandelen van gebeurtenissen. Dit bestaat uit het initialiseren van de klasse om een ingang te hebben voor het besturingselement voor wiskundige invoer en de aanroepende klasse. Daarnaast moet het besturingselement voor wiskundige invoer voor het afhandelen van gebeurtenissen worden verzonden naar de methode DispEventAdvise die door de CMathInputControlEventHandler-voorbeeldklasse wordt overgenomen. De volgende code wordt aangeroepen vanuit de methode OnInitDialog in de voorbeeldklasse om deze acties uit te voeren.

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