Dela via

Ta emot indata från matematikinmatningskontrollen

  • Artikel

I det här avsnittet beskrivs hur du hämtar MathML-markering från kontrollen för matematiska indata med hjälp av Active Template Library (ATL) och Komponentobjektmodell (COM).

Om du vill hämta den identifierade matematiska ekvationen från kontrollen för matematiska indata kan du åsidosätta det beteende som inträffar när infoga-knappen trycks in. För att göra detta måste du konfigurera en händelsehanterare som implementerar de olika händelser som stöds av _IMathInputControlEvents-gränssnittet. När du konfigurerar händelsehanteraren utförs följande steg för de händelser som du vill stödja (infoga i det här fallet).

Skapa en mallklass som innehåller händelsemottagare

När du implementerar en händelsemottagare som använder kontrollen för matematiska indata måste du först ange ett mottagar-ID. Du måste sedan skapa en mallklass som ärver från händelse-, händelsekontrollhanteraren och händelsegränssnitten för matematisk indatakontroll. Följande kod demonstrerar hur du anger ett sink-id och skapar en templateklass som CMathInputControlEventHandler, vilken ärver från de nödvändiga gränssnitten. Den här mallklassen är också konfigurerad för att ha en privat okänd gränssnittskomponent som ska användas för att överföra styrningen av matematiska indata till den vid initiering och m_ulAdviseCount-medlemmen för att räkna antalet anrop till råd/återkalla råd.

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

Obs

Medlemmen m_pMain bör vara annorlunda i implementeringen om du inte använder en dialogruta.

 

Nu när du har den grundläggande mallklassen måste du ange en framåtdeklaration för de händelsehanterare som du kommer att åsidosätta och måste sedan konfigurera en mottagarkarta för de händelser som du ska hantera. Följande kod visar hur du konfigurerar händelsehanterare för metoden Insert, som anropas när en användare klickar på infoga-knappen på kontrollen för matematiska indata, och metoden Stäng, anropad när en användare klickar på knappen Avbryt i kontrollen för matematiska indata.

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

Eftersom du kommer att arbeta med kontrollen för matematiska indata är det bra att ange en intern referens till det relevanta gränssnittet. Följande verktygsfunktion skapas i exempelklassen för att ange den här referensen.

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

Konfigurera händelsehanterarna

När du har konfigurerat händelsemottagare måste du utveckla dina implementationer av händelsemottagare. I båda metoderna i följande kodexempel hämtar händelsemottagarna en referens till gränssnittet för matematisk inmatningskontroll. I funktionen Insert visas igenkänningsresultatet som MathML och kontrollen är dold. I funktionen Stäng döljs kontrollen för matematiska indata.

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

Ärva händelsehanterarklassen i huvudklassen

När du har implementerat mallklassen måste du ärva den till den klass som du ska konfigurera din matematiska indatakontroll i. I den här guiden är den här klassen en dialogruta CMIC_TEST_EVENTSDlg. I dialoghuvudet måste de nödvändiga rubrikerna inkluderas och mallklassen som du skapade måste ärvas. Klassen du ärver inom och händelsehanterarna måste ha framåtdeklarationer så att mallen kan implementeras. I följande kodexempel visas hur det går till.

#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

Notera

Malltypen, CMIC_TEST_EventsDlg, skiljer sig om du inte har namngett klassen på samma sätt som exemplet.

 

Initiera klassen för att ärva händelsesänka

När du har konfigurerat klassen så att den ärver från mallklassen är du redo att konfigurera den för att hantera händelser. Detta består av att initiera klassen så att den har en referens till matematikinmatningskontrollen och den anropande klassen. Dessutom måste den matematiska indatakontroll som ska hantera händelser från skickas till metoden DispEventAdvise som exempelklassen CMathInputControlEventHandler ärver. Följande kod anropas från metoden OnInitDialog i exempelklassen för att utföra dessa åtgärder.

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

Not

Malltypen, CMIC_TEST_EventsDlg i det här exemplet, skiljer sig om du inte har namngett din klass på samma sätt som exemplet.