Aplicações de Monitorização

Os elementos da API da Biblioteca de Gerenciamento do Intercâmbio de Dados Dinâmico (DDEML) podem ser usados para criar um aplicativo que monitora a atividade do Intercâmbio Dinâmico de Dados (DDE) no sistema. Como qualquer aplicação DDEML, uma aplicação de monitorização DDE contém uma função de chamada de retorno DDE. O DDEML notifica a função de retorno de chamada DDE de um aplicativo de monitorização sempre que ocorre um evento DDE, passando informações sobre o evento à função de retorno de chamada. O aplicativo normalmente exibe as informações em uma janela ou grava-as em um arquivo.

Para receber notificações do DDEML, um aplicativo deve ter se registrado como um monitor DDE especificando o sinalizador APPCLASS_MONITOR ao chamar a função DdeInitialize. Nessa mesma chamada, o aplicativo pode especificar um ou mais sinalizadores de monitor para indicar os tipos de eventos para os quais o DDEML deve notificar a função de retorno de chamada do aplicativo. Os seguintes sinalizadores de monitor podem ser especificados por um aplicativo:

O exemplo a seguir mostra como registrar um aplicativo de monitoramento DDE para que sua função de retorno de chamada DDE receba notificações de todos os eventos DDE.

DWORD idInst; 
PFNCALLBACK lpDdeProc; 
hInst = hInstance; 
 
if (DdeInitialize( 
        (LPDWORD) &idInst,  // instance identifier 
        DDECallback,        // pointer to callback function 
        APPCLASS_MONITOR |  // this is a monitoring application 
        MF_CALLBACKS     |  // monitor callback functions 
        MF_CONV          |  // monitor conversation data 
        MF_ERRORS        |  // monitor DDEML errors 
        MF_HSZ_INFO      |  // monitor data handle activity 
        MF_LINKS         |  // monitor advise loops 
        MF_POSTMSGS      |  // monitor posted DDE messages 
        MF_SENDMSGS,        // monitor sent DDE messages 
        0))                 // reserved 
{
    return FALSE; 
}

O DDEML informa um aplicativo de monitoramento de um evento DDE enviando uma transação XTYP_MONITOR à função de retorno de chamada DDE da aplicação. Durante esta transação, o DDEML passa uma sinalização de monitorização que especifica o tipo de evento DDE que ocorreu e um identificador para um objeto DDE que contém informações detalhadas sobre o evento. O DDEML fornece um conjunto de estruturas que o aplicativo pode usar para extrair as informações do objeto DDE. Existe uma estrutura correspondente para cada tipo de evento DDE.

O exemplo a seguir ilustra a função de retorno de chamada DDE de uma aplicação de monitorização DDE que formata informações sobre cada evento de manipulador de cadeia de caracteres e, em seguida, exibe as informações numa janela. A função usa a estruturaMONHSZSTRUCT para extrair as informações do objeto DDE.

HDDEDATA CALLBACK DDECallback(uType, uFmt, hconv, hsz1, hsz2, 
    hdata, dwData1, dwData2) 
UINT uType; 
UINT uFmt; 
HCONV hconv; 
HSZ hsz1; 
HSZ hsz2; 
HDDEDATA hdata; 
DWORD dwData1; 
DWORD dwData2; 
{ 
    LPVOID lpData; 
    CHAR *szAction; 
    CHAR szBuf[256]; 
    DWORD cb;
    HRESULT hResult; 
 
    switch (uType) 
    { 
        case XTYP_MONITOR: 
            // Obtain a pointer to the global memory object. 
 
            if (lpData = DdeAccessData(hdata, &cb)) 
            { 
                // Examine the monitor flag. 
 
                switch (dwData2) 
                { 
                    case MF_HSZ_INFO: 
 
#define PHSZS ((MONHSZSTRUCT *)lpData) 
 
                        // The global memory object contains 
                        // string handle data. Use the MONHSZSTRUCT 
                        // structure to access the data. 
 
                        switch (PHSZS->fsAction) 
                        { 
                            // Examine the action flags to determine
                            // the action performed on the handle.
 
                            case MH_CREATE: 
                                szAction = "Created"; 
                                break; 
 
                            case MH_KEEP: 
                                szAction = "Incremented"; 
                                break; 
 
                            case MH_DELETE: 
                                szAction = "Deleted"; 
                                break; 
 
                            case MH_CLEANUP: 
                                szAction = "Cleaned up"; 
                                break; 
 
                            default: 
                                DdeUnaccessData(hdata); 
                                return (HDDEDATA) 0; 
                        } 
 
                        // Write formatted output to a buffer. 
                        hResult = StringCchPrintf(szBuf, 256/sizeof(TCHAR),
                            "Handle %s, Task: %x, Hsz: %lx(%s)", 
                            (LPSTR) szAction, PHSZS->hTask, 
                            PHSZS->hsz, (LPSTR) PHSZS->str);
                        if (FAILED(hResult))
                        {
                        // TO DO: Write error handler.
                            return;
                        } 
                        // Display text or write to a file. 
 
                        break; 
 
#undef PHSZS 
 
                    // Process other MF_* flags. 
 
                    default: 
                        break; 
                } 
            } 
 
            // Free the global memory object. 
 
            DdeUnaccessData(hdata); 
            break; 
 
        default: 
            break; 
    } 
    return (HDDEDATA) 0; 
}