Surveillance des applications de

Les éléments API de la bibliothèque de gestion DDEML (Dynamic Data Exchange Management Library) peuvent être utilisés pour créer une application qui surveille l’activité DDE (Dynamic Data Exchange) dans le système. Comme toute application DDEML, une application de supervision DDE contient une fonction de rappel DDE. Le DDEML notifie la fonction de rappel DDE d’une application de surveillance chaque fois qu’un événement DDE se produit, en transmettant des informations sur l’événement à la fonction de rappel. L’application affiche généralement les informations dans une fenêtre ou les écrit dans un fichier.

Pour recevoir des notifications du DDEML, une application doit s’être inscrite en tant que moniteur DDE en spécifiant l’indicateur APPCLASS_MONITOR dans un appel à la fonction DdeInitialize . Dans ce même appel, l’application peut spécifier un ou plusieurs indicateurs de surveillance pour indiquer les types d’événements pour lesquels le DDEML doit notifier la fonction de rappel de l’application. Les indicateurs de surveillance suivants peuvent être spécifiés par une application :

L’exemple suivant montre comment inscrire une application de supervision DDE afin que sa fonction de rappel DDE reçoive des notifications de tous les événements 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; 
}

Le DDEML informe une application de surveillance d’un événement DDE en envoyant une transaction XTYP_MONITOR à la fonction de rappel DDE de l’application. Pendant cette transaction, le DDEML transmet un indicateur de surveillance qui spécifie le type d’événement DDE qui s’est produit et un handle à un objet DDE qui contient des informations détaillées sur l’événement. DDEML fournit un ensemble de structures que l’application peut utiliser pour extraire les informations de l’objet DDE. Il existe une structure correspondante pour chaque type d’événement DDE.

L’exemple suivant montre la fonction de rappel DDE d’une application de supervision DDE qui met en forme des informations sur chaque événement de handle de chaîne, puis affiche les informations dans une fenêtre. La fonction utilise la structure MONHSZSTRUCT pour extraire les informations de l’objet 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; 
}