Петзольд. Тема DDE-(Dynamic Data Exchange)

//DDEPOP1.CPP
 
#include<windows.h>
#include<tchar.h>
 
#include<dde.h>
#include<string.h>
 
#include<stdio.h>
 
#include "ddepop1.h"
#include "..\..\..\..\..\Library\_my_header_files\RegisterClass\RegClass.h"
 
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK ServerProc(HWND, UINT, WPARAM, LPARAM);
BOOL    CALLBACK TimerEnumProc(HWND, LONG);
BOOL    CALLBACK CloseEnumProc(HWND, LONG);
BOOL             PostDataMessage(HWND, HWND, int, BOOL, BOOL, BOOL);
 
const TCHAR szMainClass[] = TEXT("DdePop1");
const TCHAR szTitle[] = TEXT("DDE population server.");
 
HINSTANCE hInstance = NULL;
 
const TCHAR szServerName[] = TEXT("DdePop1.Server");
 
 
typedef struct
{
    unsigned int fAdvise : 1;
    unsigned int fDeferUpd : 1;
    unsigned int fAckReq : 1;
    unsigned int dummy : 13;
    long         lPopPrev;
} POPADVISE;
 
#define ID_TIMER           1 
#define ID_TIMEOUT         3000 
 
 
int WINAPI _tWinMain(HINSTANCE hInst, HINSTANCE hPrevInstance,
    LPTSTR szCmdLine, int nCmdShow)
{
    hInstance = hInst;
    MSG msg = { 0 };
    HWND hwnd = NULL;
 
 
    RWC wc(hInst, WndProc, szMainClass); //Класс в котором происходит регистрация класса окна.
    wc.set_icon(hInst, szMainClass);
    if (!wc.reg_class())
        return FALSE;
 
    wc.set_wndproc(ServerProc);
    wc.set_wndextra(2 * sizeof(DWORD));
    wc.set_icon(NULL, IDI_APPLICATION);
    wc.set_class(szServerName);
    if (!wc.reg_class())
        return FALSE;
 
 
    if (!(hwnd = CreateWindow(szMainClass, szTitle,
        WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
        CW_USEDEFAULT, 0,
        CW_USEDEFAULT, 0,
        NULL, (HMENU)NULL, hInstance, NULL)))
    {
        return FALSE;
    }
 
    //Initialize 'pop' structure
    InitPops();
 
    SetTimer(hwnd, ID_TIMER, 5000, NULL);
 
 
    ShowWindow(hwnd, SW_SHOWMINNOACTIVE);
    UpdateWindow(hwnd);
 
    for (; GetMessage(&msg, NULL, 0, 0);)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
    KillTimer(hwnd, ID_TIMER);
    wc.unreg_class();
    //UnregisterClass(hInstance, szMainClass);
    return msg.wParam;
}
 
 
 
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static TCHAR szTopic[] = TEXT("US_Population");
    ATOM   aApp, aTop;
    HWND  hwndClient, hwndServer;
 
    switch (msg)
    {
    case WM_DDE_INITIATE:
    {
        //wParam          -- sending window handle
        //LOWORD(lParam)  -- application atom
        //HIWORD(lParam)  -- topic atom 
 
        hwndClient = (HWND)wParam;
        aApp = GlobalAddAtom(szMainClass);
        aTop = GlobalAddAtom(szTopic);
 
        //Check for matching atoms, create window, and acknowledge 
        if ((LOWORD(lParam) == NULL || LOWORD(lParam) == aApp) &&
            (HIWORD(lParam) == NULL || HIWORD(lParam) == aTop))
        {
            hwndServer = CreateWindow(szServerName, NULL,
                WS_CHILD, 0, 0, 0, 0,
                hwnd, NULL, hInstance, NULL);
            SetWindowLong(hwndServer, 0, (LONG)hwndClient);
            SendMessage((HWND)wParam, WM_DDE_ACK,
                (WPARAM)hwndServer, MAKELPARAM(aApp, aTop));
        }
        else  //Otherwise, delete the atoms just created
        {
            GlobalDeleteAtom(aApp);
            GlobalDeleteAtom(aTop);
        }
 
        return 0;
    }
    case WM_TIMER:
    case WM_TIMECHANGE:
    {
        //Calculate new current populations
 
        CalcPops();
 
        //Notify all child windows 
 
        EnumChildWindows(hwnd, &TimerEnumProc, 0L);
 
        return 0;
    }
    case WM_QUERYOPEN:
    {
        return 0;
    }
    case WM_CLOSE:
    {
        //Notify all child windows 
        EnumChildWindows(hwnd, &CloseEnumProc, 0L);
        break;  //for default processing
    }
    case WM_DESTROY:
    {
        PostQuitMessage(0);
        return 0;
    }
    }
    return DefWindowProc(hwnd, msg, wParam, lParam);
}
 
LRESULT CALLBACK ServerProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    ATOM  aItem;
    TCHAR szItem[10];
    DDEACK DdeAck;
    DDEADVISE* pDdeAdvise;
    DWORD dwTime;
    GLOBALHANDLE hPopAdvise, hDdeAdvise, hCommands, hDdePoke;
    UINT uiLow, uiHi;
    HWND hwndClient;
    MSG iMsg;
    POPADVISE* pPopAdvise;
    WORD  cfFormat, wStatus;
 
    switch (msg)
    {
    case WM_CREATE:
    {
        //Allocate memory for POPADVISE structures
        hPopAdvise = GlobalAlloc(GHND, NUM_STATES * sizeof(POPADVISE));
        if (hPopAdvise == NULL)
            DestroyWindow(hwnd);
        else
            SetWindowLong(hwnd, 4, (LONG)hPopAdvise);
 
        return 0;
    }
    case WM_DDE_REQUEST:
    {
        //wParam            -- sending window handle 
        //LOWORD(lParam)    -- data format
        //HIWORD(lParam)    -- item atom 
 
        hwndClient = (HWND)wParam;
        cfFormat = LOWORD(lParam);
        aItem = HIWORD(lParam);
 
        //Check for matching format and data item
        if (cfFormat == CF_UNICODETEXT)
        {
            GlobalGetAtomName(aItem, szItem, sizeof(szItem));
            int i;
            for (i = 0; i < NUM_STATES; ++i)
                if (_tcscmp(szItem, pop[i].szState) == 0)
                    break;
 
            if (i < NUM_STATES)
            {
                GlobalDeleteAtom(aItem);
                PostDataMessage(hwnd, hwndClient, i,
                    FALSE, FALSE, TRUE);
                return 0;
            }
        }
 
        //Negative acknowledge if no match 
        DdeAck.bAppReturnCode = 0;
        DdeAck.reserved = 0;
        DdeAck.fBusy = FALSE;
        DdeAck.fAck = FALSE;
 
        wStatus = *((WORD*)&DdeAck);
 
        if (!PostMessage(hwndClient, WM_DDE_ACK, (WPARAM)hwnd,
            PackDDElParam(WM_DDE_ACK, wStatus, aItem)))
        {
            GlobalDeleteAtom(aItem);
        }
 
        return 0;
    }
    case WM_DDE_ADVISE:
    {
        //wParam   --  sending window handle
        //lParam   --  DDEADVISE memory handle & item atom 
 
        UnpackDDElParam(WM_DDE_ADVISE, lParam, &uiLow, &uiHi);
        FreeDDElParam(WM_DDE_ADVISE, lParam);
 
        hwndClient = (HWND)wParam;
        hDdeAdvise = (GLOBALHANDLE)uiLow;
        aItem = (ATOM)uiHi;
 
        pDdeAdvise = (DDEADVISE*)GlobalLock(hDdeAdvise);
        if (!pDdeAdvise)
        {
            MessageBox(hwnd, TEXT("Can't memory alloc 'GlobalLock'"),
                TEXT("ERROR: DDEPOP1 --> WM_DDE_ADVISE"),
                MB_OK | MB_ICONSTOP);
            return 0;
        }
        //Check for matching format and data item
        if (pDdeAdvise->cfFormat == CF_UNICODETEXT)
        {
            GlobalGetAtomName(aItem, szItem, sizeof(szItem));
            int i;
            for (i = 0; i < NUM_STATES; ++i)
                if (_tcscmp(szItem, pop[i].szState) == 0)
                    break;
 
            //Fill in the POPADVISE structure and acknowledge 
            if (i < NUM_STATES)
            {
                hPopAdvise = (GLOBALHANDLE)GetWindowLong(hwnd, 4);
                pPopAdvise = (POPADVISE*)GlobalLock(hPopAdvise);
 
                if (!pPopAdvise)
                {
                    MessageBox(hwnd, TEXT("Can't memory alloc 'GlobalLock'"),
                        TEXT("ERROR: DDEPOP1 --> WM_DDE_ADVISE"),
                        MB_OK | MB_ICONSTOP);
                    return 0;
                }
 
                pPopAdvise[i].fAdvise = TRUE;
                pPopAdvise[i].fDeferUpd = pDdeAdvise->fDeferUpd;
                pPopAdvise[i].fAckReq = pDdeAdvise->fAckReq;
                //pPopAdvise[i].fAckReq = pDdeAdvise->fAckReq;
                pPopAdvise[i].lPopPrev = pop[i].lPop;
 
                GlobalUnlock(hDdeAdvise);
                GlobalFree(hDdeAdvise);
 
                DdeAck.bAppReturnCode = 0;
                DdeAck.reserved = 0;
                DdeAck.fBusy = FALSE;
                DdeAck.fAck = TRUE;
 
                wStatus = *((WORD*)&DdeAck);
 
                if (!PostMessage(hwndClient, WM_DDE_ACK,
                    (WPARAM)hwnd,
                    PackDDElParam(WM_DDE_ACK, wStatus, aItem)))
                {
                    GlobalDeleteAtom(aItem);
                }
                else
                {
                    PostDataMessage(hwnd, hwndClient, i,
                        pPopAdvise[i].fDeferUpd,
                        pPopAdvise[i].fAckReq,
                        FALSE);
                }
                GlobalUnlock(hPopAdvise);
                return 0;
            }
 
        }
        //Otherwise, post a negative WM_DDE_ACK 
        GlobalUnlock(hDdeAdvise);
 
        DdeAck.bAppReturnCode = 0;
        DdeAck.reserved = 0;
        DdeAck.fBusy = FALSE;
        DdeAck.fAck = FALSE;
 
        wStatus = *((WORD*)&DdeAck);
 
        if (!PostMessage(hwndClient, WM_DDE_ACK,
            (WPARAM)hwnd,
            PackDDElParam(WM_DDE_ACK, wStatus, aItem)))
        {
            GlobalFree(hDdeAdvise);
            GlobalDeleteAtom(aItem);
        }
 
        return 0;
    }
    case WM_DDE_UNADVISE:
    {
        //wParam           -- sending window handle 
        //LOWORD(lParam)   -- data format 
        //HIWORD(lParam)   -- item atom
        hwndClient = (HWND)wParam;
        cfFormat = LOWORD(lParam);
        aItem = HIWORD(lParam);
 
        DdeAck.bAppReturnCode = 0;
        DdeAck.reserved = 0;
        DdeAck.fBusy = FALSE;
        DdeAck.fAck = TRUE;
 
        hPopAdvise = (GLOBALHANDLE)GetWindowLong(hwnd, 4);
        pPopAdvise = (POPADVISE*)GlobalLock(hPopAdvise);
 
        //Check for matching format and data item
        if (cfFormat == CF_UNICODETEXT || cfFormat == NULL)
        {
            if (aItem == (ATOM)NULL)
                for (int i = 0; i < NUM_STATES; ++i)
                    pPopAdvise[i].fAdvise = FALSE;
            else
            {
                GlobalGetAtomName(aItem, szItem, sizeof(szItem));
                int i;
                for (i = 0; i < NUM_STATES; ++i)
                    if (_tcscmp(szItem, pop[i].szState) == 0)
                        break;
 
                if (i < NUM_STATES)
                    pPopAdvise[i].fAdvise = FALSE;
                else
                    DdeAck.fAck = FALSE;
            }
        }
        else
            DdeAck.fAck = FALSE;
 
        //Acknowledge either positively or negatively
        wStatus = *((WORD*)&DdeAck);
 
        if (!PostMessage(hwndClient, WM_DDE_ACK, (WPARAM)hwnd,
            PackDDElParam(WM_DDE_ACK, wStatus, aItem)))
        {
            if (aItem != (ATOM)NULL)
                GlobalDeleteAtom(aItem);
        }
 
        GlobalUnlock(hPopAdvise);
 
        return 0;
    }
    case WM_DDE_EXECUTE:
    {
        //Post negative acknowledge 
        hwndClient = (HWND)wParam;
        hCommands = (GLOBALHANDLE)lParam;
 
        DdeAck.bAppReturnCode = 0;
        DdeAck.reserved = 0;
        DdeAck.fBusy = FALSE;
        DdeAck.fAck = FALSE;
 
        wStatus = *((WORD*)&DdeAck);
 
        if (!PostMessage(hwndClient, WM_DDE_ACK, (WPARAM)hwnd,
            PackDDElParam(WM_DDE_ACK, wStatus,
                (UINT)hCommands)))
        {
            GlobalFree(hCommands);
        }
        return 0;
    }
    case WM_DDE_POKE:
    {
        //Post negative acknowledge 
        UnpackDDElParam(WM_DDE_POKE, lParam, &uiLow, &uiHi);
        FreeDDElParam(WM_DDE_POKE, lParam);
        hwndClient = (HWND)wParam;
        hDdePoke = (GLOBALHANDLE)uiLow;
        aItem = (ATOM)uiHi;
 
        DdeAck.bAppReturnCode = 0;
        DdeAck.reserved = 0;
        DdeAck.fBusy = FALSE;
        DdeAck.fAck = FALSE;
 
        wStatus = *((WORD*)&DdeAck);
 
        if (!PostMessage(hwndClient, WM_DDE_ACK, (WPARAM)hwnd,
            PackDDElParam(WM_DDE_ACK, wStatus, aItem)))
        {
            GlobalFree(hDdePoke);
            GlobalDeleteAtom(aItem);
        }
        return 0;
    }
    case WM_DDE_TERMINATE:
    {
        //Respond with another WM_DDE_TERMINATE msg 
        hwndClient = (HWND)wParam;
        PostMessage(hwndClient, WM_DDE_TERMINATE, (WPARAM)hwnd, 0L);
        DestroyWindow(hwnd);
        return 0;
    }
    case WM_TIMER:
    {
        //Post WM_DDE_DATA msgs for changed populations 
        hwndClient = (HWND)GetWindowLong(hwnd, 0);
        hPopAdvise = (GLOBALHANDLE)GetWindowLong(hwnd, 4);
        pPopAdvise = (POPADVISE*)GlobalLock(hPopAdvise);
 
        for (int i = 0; i < NUM_STATES; ++i)
            if (pPopAdvise[i].fAdvise)
                if (pPopAdvise[i].lPopPrev != pop[i].lPop)
                {
                    if (!PostDataMessage(hwnd, hwndClient, i,
                        pPopAdvise[i].fDeferUpd,
                        pPopAdvise[i].fAckReq,
                        FALSE))
                        {
                        //pPopAdvise[i].lPopPrev = pop[i].lPop;
                        break;
                        }
 
                    pPopAdvise[i].lPopPrev = pop[i].lPop;
                }
        GlobalUnlock(hPopAdvise);
        return 0;
    }
    case WM_CLOSE:
    {
        //Post a WM_DDE_TERMINATE msg to the client 
        hwndClient = (HWND)GetWindowLong(hwnd, 0);
        PostMessage(hwndClient, WM_DDE_TERMINATE, (WPARAM)hwnd, 0L);
 
        dwTime = GetCurrentTime();
        while (GetCurrentTime() - dwTime < ID_TIMEOUT)
        {
            if (PeekMessage(&iMsg, hwnd, WM_DDE_TERMINATE,
                WM_DDE_TERMINATE, PM_REMOVE))
                break;
        }
        DestroyWindow(hwnd);
        return 0;
    }
    case WM_DESTROY:
    {
        hPopAdvise = (GLOBALHANDLE)GetWindowLong(hwnd, 4);
        GlobalFree(hPopAdvise);
        return 0;
    }
    }
    return DefWindowProc(hwnd, msg, wParam, lParam);
}
 
BOOL CALLBACK TimerEnumProc(HWND hwnd, LPARAM lParam)
{
    SendMessage(hwnd, WM_TIMER, 0, 0L);
    return TRUE;
}
 
BOOL CALLBACK CloseEnumProc(HWND hwnd, LPARAM lParam)
{
    SendMessage(hwnd, WM_CLOSE, 0, 0L);
    return TRUE;
}
 
BOOL PostDataMessage(HWND hwndServer, HWND hwndClient, int iState,
    BOOL fDeferUpd, BOOL fAckReq, BOOL fResponse)
{
    ATOM aItem;
    TCHAR szPopulation[16];
    DDEACK  DdeAck;
    DDEDATA* pDdeData;
    DWORD dwTime;
    GLOBALHANDLE hDdeData;
    MSG msg;
    WORD wStatus;
 
    aItem = GlobalAddAtom(pop[iState].szState);
 
    //Allocate a DDEDATA structure if not deferred update
 
    if (fDeferUpd)
    {
        hDdeData = NULL;
    }
    else
    {
        _stprintf_s(szPopulation, 16, TEXT("%ld\r\n"), pop[iState].lPop);
        hDdeData = GlobalAlloc(GHND | GMEM_DDESHARE,
            sizeof(DDEDATA) + (_tcslen(szPopulation)));
        pDdeData = (DDEDATA*)GlobalLock(hDdeData);
        if (!pDdeData)
            return FALSE;
 
 
        pDdeData->fResponse = fResponse;
        pDdeData->fRelease = TRUE;
        pDdeData->fAckReq = fAckReq;
        pDdeData->cfFormat = CF_UNICODETEXT;
 
        _tcscpy_s((PTSTR)pDdeData->Value, 16, szPopulation);
 
        GlobalUnlock(hDdeData);
    }
 
    //Post the WM_DDE_DATA msg 
    if (!PostMessage(hwndClient, WM_DDE_DATA, (WPARAM)hwndServer,
        PackDDElParam(WM_DDE_DATA, (UINT)hDdeData, aItem)))
    {
        if (hDdeData != NULL)
            GlobalFree(hDdeData);
 
        GlobalDeleteAtom(aItem);
        return FALSE;
    }
 
    //Wait for the acknowledge msg if it's requested 
    if (fAckReq)
    {
        DdeAck.fAck = FALSE;
 
        dwTime = GetCurrentTime();
 
        while (GetCurrentTime() - dwTime < ID_TIMEOUT)
        {
            if (PeekMessage(&msg, hwndServer, WM_DDE_ACK, WM_DDE_ACK,
                PM_REMOVE))
            {
                wStatus = LOWORD(msg.lParam);
                DdeAck = *((DDEACK*)&wStatus);
                aItem = HIWORD(msg.lParam);
                GlobalDeleteAtom(aItem);
                break;
            }
        }
        if (DdeAck.fAck == FALSE)
        {
            if (hDdeData != NULL)
                GlobalFree(hDdeData);
            return FALSE;
        }
    }
    return TRUE;
}

//SHOWPOP1.CPP
 
#include<windows.h>
#include<tchar.h>
 
#include<dde.h>
#include<string.h>
 
#include "showpop1.h"
 
#include "D:\\Library\_my_header_files\RegisterClass\RegClass.h"
BOOL RegClass(WNDPROC, LPCTSTR, UINT);
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
 
const TCHAR szMainClass[] = TEXT("ShowPop1");
const TCHAR szTitle[] = TEXT("DDE Client - US population.");
 
HINSTANCE hInstance = NULL;
 
#define WM_USER_INITIATE   (WM_USER + 1) 
#define DDE_TIMEOUT        3000 
 
 
int WINAPI _tWinMain(HINSTANCE hInst, HINSTANCE hPrevInstance,
    LPTSTR szCmdLine, int nCmdShow)
{
    hInstance = hInst;
    MSG msg = { 0 };
    HWND hwnd = NULL;
 
    //if(!RegClass(WndProc, szMainClass, COLOR_WINDOW))
        //return FALSE;
 
    RWC wc(hInst, WndProc, szMainClass);
    wc.set_icon(hInst, szMainClass);
    if (!wc.reg_class())
        return FALSE;
 
 
 
    if (!(hwnd = CreateWindow(szMainClass, szTitle,
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, 0,
        CW_USEDEFAULT, 0,
        NULL, (HMENU)NULL, hInstance, NULL)))
    {
        return FALSE;
    }
 
 
    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);
 
    SendMessage(hwnd, WM_USER_INITIATE, 0, 0L);
 
    for (; GetMessage(&msg, NULL, 0, 0);)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
 
    wc.unreg_class();
    //UnregisterClass(hInstance, szMainClass);
    return msg.wParam;
}
 
 
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static BOOL fDoingInitiate = TRUE;
    static TCHAR szServerApp[] = TEXT("DdePop1"),
        szTopic[] = TEXT("US_Population");
    static char szServerAppA[] = "DdePop1",
        szTopicA[] = "US_Population";
    static HWND hwndServer = NULL;
    static long cxChar, cyChar;
    ATOM   aApp, aTop, aItem;
    TCHAR  szBuffer[24], szPopulation[16], szItem[16];
    DDEACK DdeAck;
    DDEDATA* pDdeData;
    DDEADVISE* pDdeAdvise;
    DWORD dwTime;
    GLOBALHANDLE hDdeAdvise, hDdeData;
    MSG iMsg;
    WORD wStatus;
 
    switch (msg)
    {
    case WM_CREATE:
    {
        TEXTMETRIC tm;
        HDC hdc = GetDC(hwnd);
        GetTextMetrics(hdc, &tm);
        cxChar = tm.tmAveCharWidth;
        cyChar = tm.tmHeight + tm.tmExternalLeading;
 
        ReleaseDC(hwnd, hdc);
        return 0;
    }
    case WM_USER_INITIATE:
    {
        //Broadcast WM_DDE_INITIATE iMsg
        aApp = GlobalAddAtom(szServerApp);
        aTop = GlobalAddAtom(szTopic);
 
        SendMessage(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwnd,
            MAKELONG(aApp, aTop));
 
        //If no response, try loading DDEPOP first
        if (hwndServer == NULL)
        {
            WinExec(szServerAppA, SW_SHOWMINNOACTIVE);
            SendMessage(HWND_BROADCAST, WM_DDE_INITIATE,
                (WPARAM)hwnd, MAKELONG(aApp, aTop));
        }
 
        //Delete the atoms 
        GlobalDeleteAtom(aApp);
        GlobalDeleteAtom(aTop);
        fDoingInitiate = FALSE;
 
        //If still no response, display message box 
 
        if (hwndServer == NULL)
        {
            MessageBox(hwnd,
                TEXT("Cannot connect with DDEPOP1.EXE!"),
                szMainClass, MB_ICONEXCLAMATION | MB_OK);
            return 0;
        }
 
        //Post WM_DDE_ADVISE iMsgs
        int i;
        for (i = 0; i < NUM_STATES; ++i)
        {
            hDdeAdvise = GlobalAlloc(GHND | GMEM_DDESHARE,
                sizeof(DDEADVISE));
            if (!hDdeAdvise)
            {
                MessageBox(hwnd,
                    TEXT("Can't memory alloc 'GlobalAlloc'"),
                    szMainClass, MB_OK);
                return 0;
            }
            pDdeAdvise = (DDEADVISE*)GlobalLock(hDdeAdvise);
            if (!pDdeAdvise)
            {
                MessageBox(hwnd,
                    TEXT("Can't memory alloc 'GlobalLock'"),
                    szMainClass, MB_OK);
                return 0;
            }
            pDdeAdvise->fAckReq = TRUE;
            pDdeAdvise->fDeferUpd = FALSE;
            pDdeAdvise->cfFormat = CF_UNICODETEXT;
 
            GlobalUnlock(hDdeAdvise);
 
            aItem = GlobalAddAtom(pop[i].szAbb);
 
            if (!PostMessage(hwndServer, WM_DDE_ADVISE,
                (WPARAM)hwnd,
                PackDDElParam(WM_DDE_ADVISE,
                    (UINT)hDdeAdvise, aItem)))
            {
                GlobalFree(hDdeAdvise);
                GlobalDeleteAtom(aItem);
                break;
            }
            DdeAck.fAck = FALSE;
 
            dwTime = GetCurrentTime();
 
            while (GetCurrentTime() - dwTime < DDE_TIMEOUT)
            {
                if (PeekMessage(&iMsg, hwnd, WM_DDE_ACK,
                    WM_DDE_ACK, PM_REMOVE))
                {
                    GlobalDeleteAtom(HIWORD(iMsg.lParam));
 
                    wStatus = LOWORD(iMsg.lParam);
 
                    DdeAck = *((DDEACK*)&wStatus);
 
                    if (DdeAck.fAck == FALSE)
                    {
                        GlobalFree(hDdeAdvise);
                    }
                    break;
                }
            }
 
            if (DdeAck.fAck == FALSE)
                break;
 
            while (PeekMessage(&iMsg, hwnd, WM_DDE_FIRST,
                WM_DDE_LAST, PM_REMOVE))
            {
                DispatchMessage(&iMsg);
            }
        }
        if (i < NUM_STATES)
        {
            MessageBox(hwnd, TEXT("Failure on WM_DDE_ADVISE!"),
                szMainClass, MB_ICONEXCLAMATION | MB_OK);
        }
        return 0;
    }
    case WM_DDE_ACK:
    {
        //In response to WM_DDE_INITIATE, save server window 
        unsigned int uiLow, uiHi;
        if (fDoingInitiate)
        {
            UnpackDDElParam(WM_DDE_ACK, lParam, &uiLow, &uiHi);
            if (!FreeDDElParam(WM_DDE_ACK, lParam))
            {
                DWORD er = GetLastError();
                DWORD eer = er;
            }
            hwndServer = (HWND)wParam;
            GlobalDeleteAtom((ATOM)uiLow);
            GlobalDeleteAtom((ATOM)uiHi);
        }
        return 0;
    }
    case WM_DDE_DATA:
    {
        //wParam  -- sending window handle
        //lParam  -- DDEDATA memory handle & item atom
        unsigned int uiLow, uiHi;
        UnpackDDElParam(WM_DDE_DATA, lParam, &uiLow, &uiHi);
        FreeDDElParam(WM_DDE_DATA, lParam);
 
        hDdeData = (GLOBALHANDLE)uiLow;
        pDdeData = (DDEDATA*)GlobalLock(hDdeData);
        aItem = (ATOM)uiHi;
 
        //Initialize DdeAck structure 
        DdeAck.bAppReturnCode = 0;
        DdeAck.reserved = 0;
        DdeAck.fBusy = FALSE;
        DdeAck.fAck = FALSE;
 
        //Check for matching format and data item 
        if (pDdeData->cfFormat == CF_UNICODETEXT)
        {
            GlobalGetAtomName(aItem, szItem, sizeof(szItem));
            int i;
            for (i = 0; i < NUM_STATES; ++i)
                if (_tcscmp(szItem, pop[i].szAbb) == 0)
                    break;
 
            if (i < NUM_STATES)
            {
                _tcscpy_s(szPopulation, 16, (TCHAR*)pDdeData->Value);
                pop[i].lPop = _tstol(szPopulation);
                InvalidateRect(hwnd, NULL, FALSE);
 
                DdeAck.fAck = TRUE;
            }
        }
 
        //Acknowledge if necessary
        if (pDdeData->fAckReq == TRUE)
        {
            wStatus = *((WORD*)&DdeAck);
            if (!PostMessage((HWND)wParam, WM_DDE_ACK, (WPARAM)hwnd,
                PackDDElParam(WM_DDE_ACK, wStatus,
                    aItem)))
            {
                GlobalDeleteAtom(aItem);
                GlobalUnlock(hDdeData);
                GlobalFree(hDdeData);
                return 0;
            }
        }
        else
        {
            GlobalDeleteAtom(aItem);
        }
 
        //Clean Up
        if (pDdeData->fRelease == TRUE || DdeAck.fAck == FALSE)
        {
            GlobalUnlock(hDdeData);
            GlobalFree(hDdeData);
        }
        else
        {
            GlobalUnlock(hDdeData);
        }
        return 0;
    }
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hwnd, &ps);
 
        int x, y;
        for (int i = 0; i < NUM_STATES; ++i)
        {
            if (i < (NUM_STATES + 1) / 2)
            {
                x = cxChar;
                y = i * cyChar;
            }
            else
            {
                x = 44 * cxChar;
                y = (i - (NUM_STATES + 1) / 2) * cyChar;
            }
 
            TextOut(hdc, x, y, szBuffer,
                _stprintf_s(szBuffer, 24, TEXT("%-20s"),
                    (PTSTR)pop[i].szState));
            x += 36 * cxChar;
 
            SetTextAlign(hdc, TA_RIGHT | TA_TOP);
 
            TextOut(hdc, x, y, szBuffer,
                _stprintf_s(szBuffer, 24, TEXT("%10ld"),
                    pop[i].lPop));
            SetTextAlign(hdc, TA_LEFT | TA_TOP);
        }
        EndPaint(hwnd, &ps);
        return 0;
    }
    case WM_DDE_TERMINATE:
    {
        //Respond with another WM_DDE_TERMINATE iMsg 
        PostMessage(hwndServer, WM_DDE_TERMINATE, (WPARAM)hwnd, 0L);
        hwndServer = NULL;
        return 0;
    }
    case WM_CLOSE:
    {
        if (hwndServer == NULL)
            break;
 
        //Post WM_DDE_UNADVISE iMsg
        PostMessage(hwndServer, WM_DDE_UNADVISE, (WPARAM)hwnd,
            MAKELONG(CF_UNICODETEXT, NULL));
 
        dwTime = GetCurrentTime();
 
        while (GetCurrentTime() - dwTime < DDE_TIMEOUT)
        {
            if (PeekMessage(&iMsg, hwnd, WM_DDE_ACK, WM_DDE_ACK,
                PM_REMOVE))
                break;
        }
 
        //Post WM_DDE_TERMINATE iMsg 
        PostMessage(hwndServer, WM_DDE_TERMINATE, (WPARAM)hwnd, 0L);
 
        dwTime = GetCurrentTime();
 
        while (GetCurrentTime() - dwTime < DDE_TIMEOUT)
        {
            if (PeekMessage(&iMsg, hwnd, WM_DDE_TERMINATE,
                WM_DDE_TERMINATE, PM_REMOVE))
                break;
        }
        break; //for default processing
    }
    case WM_DESTROY:
    {
        PostQuitMessage(0);
        return 0;
    }
    }
    return DefWindowProc(hwnd, msg, wParam, lParam);
}

case WM_USER_INITIATE:
    {
        //Broadcast WM_DDE_INITIATE iMsg
        aApp = GlobalAddAtom(szServerApp);
        aTop = GlobalAddAtom(szTopic);
 
        SendMessage(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwnd,
            MAKELONG(aApp, aTop));
 
        //If no response, try loading DDEPOP first
        if (hwndServer == NULL)
        {
            WinExec(szServerAppA, SW_SHOWMINNOACTIVE);
            SendMessage(HWND_BROADCAST, WM_DDE_INITIATE,
                (WPARAM)hwnd, MAKELONG(aApp, aTop));
        }
 
        //Delete the atoms 
        GlobalDeleteAtom(aApp);
        GlobalDeleteAtom(aTop);
        fDoingInitiate = FALSE;
 
        //If still no response, display message box 
 
        if (hwndServer == NULL)
        {
            MessageBox(hwnd,
                TEXT("Cannot connect with DDEPOP1.EXE!"),
                szMainClass, MB_ICONEXCLAMATION | MB_OK);
            return 0;
        }
 
        //Post WM_DDE_ADVISE iMsgs
        int i;
        for (i = 0; i < NUM_STATES; ++i)
        {
            hDdeAdvise = GlobalAlloc(GHND | GMEM_DDESHARE,
                sizeof(DDEADVISE));
            if (!hDdeAdvise)
            {
                MessageBox(hwnd,
                    TEXT("Can't memory alloc 'GlobalAlloc'"),
                    szMainClass, MB_OK);
                return 0;
            }
            pDdeAdvise = (DDEADVISE*)GlobalLock(hDdeAdvise);
            if (!pDdeAdvise)
            {
                MessageBox(hwnd,
                    TEXT("Can't memory alloc 'GlobalLock'"),
                    szMainClass, MB_OK);
                return 0;
            }
            pDdeAdvise->fAckReq = TRUE;
            pDdeAdvise->fDeferUpd = FALSE;
            pDdeAdvise->cfFormat = CF_UNICODETEXT;
 
            GlobalUnlock(hDdeAdvise);
 
            aItem = GlobalAddAtom(pop[i].szAbb);
 
            if (!PostMessage(hwndServer, WM_DDE_ADVISE,
                (WPARAM)hwnd,
                PackDDElParam(WM_DDE_ADVISE,
                    (UINT)hDdeAdvise, aItem)))
            {
                GlobalFree(hDdeAdvise);
                GlobalDeleteAtom(aItem);
                break;
            }
            DdeAck.fAck = FALSE;
 
            dwTime = GetCurrentTime();
 
            while (GetCurrentTime() - dwTime < DDE_TIMEOUT)
            {
                if (PeekMessage(&iMsg, hwnd, WM_DDE_ACK,
                    WM_DDE_ACK, PM_REMOVE))
                {
                    GlobalDeleteAtom(HIWORD(iMsg.lParam));
 
                    wStatus = LOWORD(iMsg.lParam);
 
                    DdeAck = *((DDEACK*)&wStatus);
 
                    if (DdeAck.fAck == FALSE)
                    {
                        GlobalFree(hDdeAdvise);
                    }
                    break;
                }
            }
 
            if (DdeAck.fAck == FALSE)
                break;
 
            while (PeekMessage(&iMsg, hwnd, WM_DDE_FIRST,
                WM_DDE_LAST, PM_REMOVE))
            {
                DispatchMessage(&iMsg);
            }
        }
        if (i < NUM_STATES) //Здесь она сообщает, что что-то не так. 
        {
                    
            MessageBox(hwnd, TEXT("Failure on WM_DDE_ADVISE!"),
                szMainClass, MB_ICONEXCLAMATION | MB_OK);
        }
        return 0;
    }

DWORD dwCountOfMessagesDdeAck = 0;
 
 
while(GetMessage(&msg, NULL, 0, 0))
{
    if(msg.message == WM_DDE_ACK)
    {
        if((msg.time - dwTime) > DDE_TIMEOUT)
        {
            if(dwCountOfMessagesDdeAck != DDE_STATES)
            {
                //ERROR MESSAGE
            }
        }   
        else 
            ++dwCountOfMessagesDdeAck;
    }
    TranslateMessage(&msg);
    DispatchMessage(&msg);
}
 
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
        case WM_USET_INITIATE:
        {
            //hDdeAdvise = GlobalAlloc(GHND, sizeof(DDEADVISE));
            //pDdeAdvise = GlobalLock(hDdeAdvise);
            //.........
            if(!PostMessage(hwndServer, WM_DDE_ASVISE, (WPARAM)hwnd,
                            PackDDElParam(WM_DDE_ADVISE, 
                                          hDdeAdvise, aAtom)))
            {
                GlobalFree(hDdeAdvise);
                GlobalDeleteAtom(aAtom);
                return 0;
            }
            
            dwTimeBeg = GetCurrentTime();
            
            //.........
            //GlobalUnlock(hDdeAdvise);
            //GlobalFree(hDdeAdvise);
        }
        case WM_DDE_ACK:
        {
            if(fDoingInitiate)
            {
                 uiLow = LOWORD(lParam); 
                 uiHi = HIWORD(lParam);
                 hwndServer = (HWND)wParam;
                 GlobalDeleteAtom((ATOM)uiLow);
                 GlobalDeleteAtom((ATOM)uiHi);
            }
            else
            {
                UnpackDDElParam(WM_DDE_ACK, lParam, &uiLow, &uiHi);
                FreeDDElParam(WM_DDE_ACK, lParam);
                
                GlobalDeleteAtom((ATOM)uiHi);
                //WORD wStatus = *(DDEACK*)&uiLow;
            }
            return 0;
        }
    }
}