Partilhar via

Adicionando um evento (ATL Tutorial, Parte 5)

Nesta etapa, você adicionará um ClickIn e um ClickOut evento ao seu controle ATL. Você disparará o ClickIn evento se o usuário clicar dentro do polígono e disparará ClickOut se o usuário clicar fora. As tarefas para adicionar um evento são as seguintes:

  • Adicionando os métodos ClickIn e ClickOut

  • Gerando a biblioteca de tipos

  • Implementando as interfaces de ponto de conexão

Adicionando os métodos ClickIn e ClickOut

Quando você criou o controle ATL na etapa 2, você marcou a caixa de seleção Pontos de conexão . Isso criou a _IPolyCtlEvents interface no arquivo Polygon.idl. Observe que o nome da interface começa com um sublinhado. Esta é uma convenção para indicar que a interface é uma interface interna. Assim, os programas que permitem navegar em objetos COM podem optar por não exibir a interface para o usuário. Observe também que selecionar Pontos de conexão adicionou a seguinte linha no arquivo Polygon.idl para indicar que _IPolyCtlEvents é a interface de origem padrão:

[default, source] dispinterface _IPolyCtlEvents;

O atributo source indica que o controle é a fonte das notificações, portanto, ele chamará essa interface no contêiner.

Agora adicione os métodos ClickIn e ClickOut à interface _IPolyCtlEvents.

Para adicionar os métodos ClickIn e ClickOut

  1. No Explorador de Soluções, abra Polygon.idl e adicione o seguinte código na declaração methods: da biblioteca PolygonLib:

    [id(1), helpstring("method ClickIn")] void ClickIn([in] LONG x,[in] LONG y);
[id(2), helpstring("method ClickOut")] void ClickOut([in] LONG x,[in] LONG y);

Os ClickIn métodos e ClickOut tomam as coordenadas x e y do ponto clicado como parâmetros.

Gerando a biblioteca de tipos

Gere a biblioteca de tipos neste ponto, porque o projeto a usará para obter as informações necessárias para construir uma interface de ponto de conexão e uma interface de contêiner de ponto de conexão para seu controle.

Para gerar a biblioteca de tipos

  1. Reconstrua o seu projeto.

    -ou-

  2. Clique com o botão direito do mouse no arquivo Polygon.idl no Gerenciador de Soluções e clique em Compilar no menu de atalho.

Isso criará o arquivo Polygon.tlb, que é sua biblioteca de tipos. O arquivo Polygon.tlb não é visível do Gerenciador de Soluções, porque é um arquivo binário e não pode ser exibido ou editado diretamente.

Implementando as interfaces de ponto de conexão

Implemente uma interface de ponto de conexão e uma interface de contêiner de ponto de conexão para seu controle. Em COM, os eventos são implementados através do mecanismo de pontos de conexão. Para receber eventos de um objeto COM, um contêiner estabelece uma conexão de aviso com o ponto de conexão que o objeto COM implementa. Como um objeto COM pode ter vários pontos de conexão, o objeto COM também implementa uma interface de contêiner de ponto de conexão. Através dessa interface, o contêiner pode determinar quais pontos de conexão são suportados.

A interface que implementa um ponto de conexão é chamada IConnectionPointde , e a interface que implementa um contêiner de ponto de conexão é chamada IConnectionPointContainerde .

Para ajudar a implementar IConnectionPoint, utilizará o Assistente de Implementação de Ponto de Conexão. Este assistente gera a IConnectionPoint interface lendo sua biblioteca de tipos e implementando uma função para cada evento que pode ser acionado.

Para implementar os pontos de conexão

  1. No Gerenciador de Soluções, abra _IPolyCtlEvents_CP.h e adicione o seguinte código sob a public: instrução na CProxy_IPolyCtlEvents classe:

    VOID Fire_ClickIn(LONG x, LONG y)
{
    T* pT = static_cast<T*>(this);
    int nConnectionIndex;
    CComVariant* pvars = new CComVariant[2];
    int nConnections = m_vec.GetSize();

    for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++)
    {
        pT->Lock();
        CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
        pT->Unlock();
        IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
        if (pDispatch != NULL)
        {
            pvars[1].vt = VT_I4;
            pvars[1].lVal = x;
            pvars[0].vt = VT_I4;
            pvars[0].lVal = y;
            DISPPARAMS disp = { pvars, NULL, 2, 0 };
            pDispatch->Invoke(0x1, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, NULL, NULL, NULL);
        }
    }
    delete[] pvars;

}
VOID Fire_ClickOut(LONG x, LONG y)
{
    T* pT = static_cast<T*>(this);
    int nConnectionIndex;
    CComVariant* pvars = new CComVariant[2];
    int nConnections = m_vec.GetSize();

    for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++)
    {
        pT->Lock();
        CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
        pT->Unlock();
        IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
        if (pDispatch != NULL)
        {
            pvars[1].vt = VT_I4;
            pvars[1].lVal = x;
            pvars[0].vt = VT_I4;
            pvars[0].lVal = y;
            DISPPARAMS disp = { pvars, NULL, 2, 0 };
            pDispatch->Invoke(0x2, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, NULL, NULL, NULL);
        }
    }
    delete[] pvars;

}

Você verá que esse arquivo tem uma classe chamada CProxy_IPolyCtlEvents que deriva de IConnectionPointImpl. _IPolyCtlEvents_CP.h agora define os dois métodos Fire_ClickIn e Fire_ClickOut, que tomam os dois parâmetros de coordenadas. Você chama esses métodos quando deseja disparar um evento do seu controle.

Ao criar o controle com a opção Pontos de conexão selecionada, o arquivo _IPolyCtlEvents_CP.h foi gerado para você. Ele também adicionou CProxy_PolyEvents e IConnectionPointContainerImpl à lista de herança múltipla do seu controle e expôs IConnectionPointContainer para você adicionando entradas apropriadas ao mapa COM.

Você terminou de implementar o código para dar suporte a eventos. Agora, adicione algum código para disparar os eventos no momento apropriado. Lembre-se de que será disparado um evento ClickIn ou ClickOut quando o utilizador clica no botão esquerdo do rato no controlo. Para descobrir quando o usuário clica no botão, adicione um manipulador para a WM_LBUTTONDOWN mensagem.

Para adicionar um manipulador para a mensagem WM_LBUTTONDOWN

  1. No Modo de Exibição de Classe, clique com o botão direito do mouse na CPolyCtl classe e clique em Propriedades no menu de atalho.

  2. Na janela Propriedades , clique no ícone Mensagens e, em seguida, clique WM_LBUTTONDOWN na lista à esquerda.

  3. Na lista suspensa exibida, clique em <Adicionar> OnLButtonDown. A OnLButtonDown declaração do manipulador será adicionada ao PolyCtl.h e a implementação do manipulador será adicionada ao PolyCtl.cpp.

Em seguida, modifique o manipulador.

Para modificar o método OnLButtonDown

  1. Altere o código que compreende o OnLButtonDown método em PolyCtl.cpp (excluindo qualquer código colocado pelo assistente) para que tenha esta aparência:

    LRESULT CPolyCtl::OnLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, 
   BOOL& /*bHandled*/)
{
   HRGN hRgn;
   WORD xPos = LOWORD(lParam);  // horizontal position of cursor
   WORD yPos = HIWORD(lParam);  // vertical position of cursor

   CalcPoints(m_rcPos);

   // Create a region from our list of points
   hRgn = CreatePolygonRgn(&m_arrPoint[0], m_nSides, WINDING);

   // If the clicked point is in our polygon then fire the ClickIn
   //  event otherwise we fire the ClickOut event
   if (PtInRegion(hRgn, xPos, yPos))
      Fire_ClickIn(xPos, yPos);
   else
      Fire_ClickOut(xPos, yPos);

   // Delete the region that we created
   DeleteObject(hRgn);
   return 0;
}

Esse código usa os pontos calculados na OnDraw função para criar uma região que deteta os cliques do mouse do usuário com a chamada para PtInRegion.

O parâmetro uMsg é a ID da mensagem do Windows que está sendo manipulada. Isso permite que você tenha uma função que lida com uma variedade de mensagens. Os parâmetros wParam e lParam são os valores padrão para a mensagem que está sendo manipulada. O parâmetro bHandled permite especificar se a função manipulou a mensagem ou não. Por padrão, o valor é definido como TRUE para indicar que a função manipulou a mensagem, mas você pode defini-lo como FALSE. Isso fará com que a ATL continue procurando outra função de manipulador de mensagens para enviar a mensagem.

Construindo e testando o controle

Agora experimente os seus eventos. Crie o controle e inicie o contêiner de teste de controle ActiveX novamente. Desta vez, exiba a janela do log de eventos. Para rotear eventos para a janela de saída, clique em Registro no menu Opções e selecione Registrar na janela de saída. Insira o controle e tente clicar na janela. Observe que ClickIn é acionado se você clicar dentro do polígono preenchido e ClickOut é acionado quando você clica fora dele.

Em seguida, você adicionará uma página de propriedades.

Voltar ao Passo 4 | Rumo ao Passo 6

Ver também

Tutoriais

  • Last updated on