Partager via

Réception d’une entrée à partir du contrôle d’entrée mathématique

  • Article

Cette section explique comment récupérer le balisage MathML à partir du contrôle d’entrée mathématique à l’aide de la bibliothèque de modèles actifs (ATL) et du modèle objet de composant (COM).

Pour récupérer l’équation mathématique reconnue à partir du contrôle d’entrée mathématique, vous pouvez remplacer le comportement qui se produit lorsque le bouton Insérer est enfoncé. Pour ce faire, vous devez configurer un gestionnaire d’événements qui implémente les différents événements pris en charge par l’interface _IMathInputControlEvents . La configuration du gestionnaire d’événements implique l’exécution des étapes suivantes pour les événements que vous souhaitez prendre en charge (insérez dans ce cas).

Créer une classe de modèle qui contient des récepteurs d’événements

Lorsque vous implémentez un récepteur d’événements qui utilise le contrôle d’entrée mathématique, vous devez d’abord spécifier un ID de récepteur. Vous devez ensuite créer une classe de modèle qui hérite de l’événement, du gestionnaire de contrôle d’événements et des interfaces d’événement de contrôle d’entrée mathématiques. Le code suivant montre comment définir un ID de récepteur et créer une classe de modèle, CMathInputControlEventHandler, qui hérite des interfaces requises. Cette classe de modèle est également configurée pour avoir un pointeur d’interface inconnu privé qui sera utilisé pour lui passer le contrôle d’entrée mathématique lors de l’initialisation et le membre m_ulAdviseCount pour compter le nombre d’appels à conseiller/désadviser.

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

Notes

Le membre m_pMain doit être différent dans votre implémentation si vous n’utilisez pas de boîte de dialogue.

 

Maintenant que vous disposez de la classe de modèle de base, vous devez fournir une déclaration de transfert pour les gestionnaires d’événements que vous allez remplacer, puis configurer une carte récepteur pour les événements que vous allez gérer. Le code suivant montre comment configurer des gestionnaires d’événements pour la méthode Insert , appelée lorsqu’un utilisateur clique sur le bouton Insérer sur le contrôle d’entrée mathématique, et la méthode Close , appelée lorsqu’un utilisateur clique sur le bouton Annuler sur le contrôle d’entrée mathématique.

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

Étant donné que vous allez utiliser le contrôle d’entrée mathématique, il est utile de définir une référence interne à l’interface appropriée. La fonction utilitaire suivante est créée dans l’exemple de classe pour définir cette référence.

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

Configurer les gestionnaires d’événements

Une fois que vous avez configuré les récepteurs d’événements, vous devez créer vos implémentations des récepteurs d’événements. Dans les deux méthodes de l’exemple de code suivant, les récepteurs d’événements récupèrent un handle vers l’interface de contrôle d’entrée mathématique. Dans la fonction Insert , le résultat de la reconnaissance s’affiche sous la forme MathML et le contrôle est masqué. Dans la fonction Close , le contrôle d’entrée mathématique est masqué.

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

Hériter de la classe de gestionnaire d’événements dans votre classe main

Une fois votre classe de modèle implémentée, vous devez l’hériter dans la classe dans laquelle vous allez configurer votre contrôle d’entrée mathématique. Pour les besoins de ce guide, cette classe est une boîte de dialogue, CMIC_TEST_EVENTSDlg. Dans l’en-tête de boîte de dialogue, les en-têtes requis doivent être inclus et la classe de modèle que vous avez créée doit être héritée. La classe dont vous héritez et les gestionnaires d’événements doivent avoir des déclarations de transfert pour que le modèle puisse être implémenté. L’exemple de code suivant montre comment procéder.

#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

Notes

Le type de modèle, CMIC_TEST_EventsDlg, sera différent, sauf si vous avez nommé votre classe comme dans l’exemple.

 

Initialisez votre classe pour hériter du ou des récepteurs d’événements

Une fois que vous avez configuré votre classe pour hériter de la classe de modèle, vous êtes prêt à la configurer pour gérer les événements. Cela consiste à initialiser la classe pour avoir un handle au contrôle d’entrée mathématique et à la classe appelante. En outre, le contrôle d’entrée mathématique à partir duquel gérer les événements doit être envoyé à la méthode DispEventAdvise héritée de l’exemple de classe CMathInputControlEventHandler. Le code suivant est appelé à partir de la méthode OnInitDialog dans l’exemple de classe pour effectuer ces actions.

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

Notes

Le type de modèle, CMIC_TEST_EventsDlg dans cet exemple, sera différent, sauf si vous avez nommé votre classe de la même façon que l’exemple.