Петзольд. Тема 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;
    }

/*---------------------------------------------
   DDEPOP1.C -- DDE Server for Population Data
                (c) Charles Petzold, 1996
  ---------------------------------------------*/
 
#include <windows.h>
#include <dde.h>
#include <string.h>
#include "ddepop.h"
 
#include<stdio.h>
 
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 DDE_TIMEOUT 3000
 
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);
 
char      szAppName[] = "DdePop1";
char      szServerClass[] = "DdePop1.Server";
HINSTANCE hInst;
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    PSTR szCmdLine, int iCmdShow)
{
    HWND        hwnd;
    MSG         msg;
    WNDCLASSEXA  wndclass;
 
    hInst = hInstance;
 
    // Register window class
 
    wndclass.cbSize = sizeof(wndclass);
    wndclass.style = 0;
    wndclass.lpfnWndProc = WndProc;
    wndclass.cbClsExtra = 0;
    wndclass.cbWndExtra = 0;
    wndclass.hInstance = hInstance;
    wndclass.hIcon = LoadIconA(hInstance, szAppName);
    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wndclass.lpszMenuName = NULL;
    wndclass.lpszClassName = szAppName;
    wndclass.hIconSm = LoadIconA(hInstance, szAppName);
 
    RegisterClassExA(&wndclass);
 
    // Register window class for DDE Server
 
    wndclass.cbSize = sizeof(wndclass);
    wndclass.style = 0;
    wndclass.lpfnWndProc = ServerProc;
    wndclass.cbClsExtra = 0;
    wndclass.cbWndExtra = 2 * sizeof(DWORD);
    wndclass.hInstance = hInstance;
    wndclass.hIcon = NULL;
    wndclass.hCursor = NULL;
    wndclass.hbrBackground = NULL;
    wndclass.lpszMenuName = NULL;
    wndclass.lpszClassName = szServerClass;
    wndclass.hIconSm = NULL;
 
    RegisterClassExA(&wndclass);
 
    hwnd = CreateWindowA(szAppName, "DDE Population Server",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, hInstance, NULL);
 
    InitPops();                      // initialize 'pop' structure
 
    SetTimer(hwnd, ID_TIMER, 5000, NULL);
 
    ShowWindow(hwnd, SW_SHOWMINNOACTIVE);
    UpdateWindow(hwnd);
 
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
    KillTimer(hwnd, ID_TIMER);
 
    return msg.wParam;
}
 
LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
    static char szTopic[] = "US_Population";
    ATOM        aApp, aTop;
    HWND        hwndClient, hwndServer;
 
    switch (iMsg)
    {
    case WM_DDE_INITIATE:
 
        // wParam          -- sending window handle
        // LOWORD (lParam) -- application atom
        // HIWORD (lParam) -- topic atom
 
        hwndClient = (HWND)wParam;
 
        aApp = GlobalAddAtomA(szAppName);
        aTop = GlobalAddAtomA(szTopic);
 
        // Check for matching atoms, create window, and acknowledge
 
        if ((LOWORD(lParam) == NULL || LOWORD(lParam) == aApp) &&
            (HIWORD(lParam) == NULL || HIWORD(lParam) == aTop))
        {
            hwndServer = CreateWindowA(szServerClass, NULL,
                WS_CHILD, 0, 0, 0, 0,
                hwnd, NULL, hInst, NULL);
            if (!hwndServer)
            {
                MessageBox(hwnd, TEXT("Can't creating a window"),
                    TEXT("Error: DDEPOP1_A"), MB_OK);
                GlobalDeleteAtom(aApp);
                GlobalDeleteAtom(aTop);
                return 0;
            }
 
            SetWindowLongPtr(hwndServer, 0, (ULONG_PTR)hwndClient);
            SendMessage((HWND)wParam, WM_DDE_ACK,
                (WPARAM)hwndServer,
                MAKELPARAM(aApp, aTop));
        }
 
        // Otherwise, delete the atoms just created
 
        else
        {
            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, iMsg, wParam, lParam);
}
 
LRESULT CALLBACK ServerProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
    ATOM          aItem;
    char          szItem[10];
    DDEACK        DdeAck;
    DDEADVISE* pDdeAdvise;
    DWORD         dwTime;
    GLOBALHANDLE  hPopAdvise, hDdeAdvise, hCommands, hDdePoke;
    int           i;
    UINT          uiLow, uiHi;
    HWND          hwndClient;
    MSG           msg;
    POPADVISE* pPopAdvise;
    WORD          cfFormat, wStatus;
 
    switch (iMsg)
    {
    case WM_CREATE:
 
        // Allocate memory for POPADVISE structures
 
        hPopAdvise = GlobalAlloc(GHND, NUM_STATES * sizeof(POPADVISE));
 
        if (hPopAdvise == NULL)
            DestroyWindow(hwnd);
        else
            SetWindowLongPtr(hwnd, sizeof(DWORD), (ULONG_PTR)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_TEXT)
        {
            GlobalGetAtomNameA(aItem, szItem, sizeof(szItem));
 
            for (i = 0; i < NUM_STATES; i++)
                if (strcmp(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);
 
        // Check for matching format and data item
 
        if (pDdeAdvise->cfFormat == CF_TEXT)
        {
            GlobalGetAtomNameA(aItem, szItem, sizeof(szItem));
 
            for (i = 0; i < NUM_STATES; i++)
                if (strcmp(szItem, pop[i].szState) == 0)
                    break;
 
            // Fill in the POPADVISE structure and acknowledge
 
            if (i < NUM_STATES)
            {
                hPopAdvise = (GLOBALHANDLE)GetWindowLongPtr(hwnd, sizeof(DWORD));
                pPopAdvise = (POPADVISE*)
                    GlobalLock(hPopAdvise);
 
                pPopAdvise[i].fAdvise = TRUE;
                pPopAdvise[i].fDeferUpd = pDdeAdvise->fDeferUpd;
                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;
            }
            else
            {
                MessageBox(hwnd, TEXT("WM_DDE_ASVISE (i >= NUM_STATES)"),
                    TEXT("ERROR: DDEPOP1_A.exe"),
                    MB_OK | MB_ICONSTOP);
            }
        }
        else
        {
            MessageBox(hwnd, 
                TEXT("WM_DDE_ASVISE (pPopAdvise.cfFormat != CF_TEXT)"),
                TEXT("ERROR: DDEPOP1_A.exe"),
                MB_OK | MB_ICONSTOP);
        }
 
        // 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);
            FreeDDElParam(WM_DDE_ACK, lParam);
        }
 
        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)GetWindowLongPtr(hwnd, sizeof(DWORD));
        pPopAdvise = (POPADVISE*)GlobalLock(hPopAdvise);
 
        // Check for matching format and data item
 
        if (cfFormat == CF_TEXT || cfFormat == NULL)
        {
            if (aItem == (ATOM)NULL)
                for (i = 0; i < NUM_STATES; i++)
                    pPopAdvise[i].fAdvise = FALSE;
            else
            {
                GlobalGetAtomNameA(aItem, szItem, sizeof(szItem));
 
                for (i = 0; i < NUM_STATES; i++)
                    if (strcmp(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 iMsg
 
        hwndClient = (HWND)wParam;
        PostMessage(hwndClient, WM_DDE_TERMINATE, (WPARAM)hwnd, 0L);
        DestroyWindow(hwnd);
        return 0;
 
    case WM_TIMER:
 
        // Post WM_DDE_DATA iMsgs for changed populations
 
        hwndClient = (HWND)GetWindowLongPtr(hwnd, 0);
        hPopAdvise = (GLOBALHANDLE)GetWindowLongPtr(hwnd, sizeof(DWORD));
        pPopAdvise = (POPADVISE*)GlobalLock(hPopAdvise);
 
        for (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))
                        break;
 
                    pPopAdvise[i].lPopPrev = pop[i].lPop;
                }
        }
        GlobalUnlock(hPopAdvise);
        return 0;
 
    case WM_CLOSE:
 
        // Post a WM_DDE_TERMINATE iMsg to the client
 
        hwndClient = (HWND)GetWindowLongPtr(hwnd, 0);
        PostMessage(hwndClient, WM_DDE_TERMINATE, (WPARAM)hwnd, 0L);
 
        dwTime = GetCurrentTime();
 
        while (GetCurrentTime() - dwTime < DDE_TIMEOUT)
            if (PeekMessage(&msg, hwnd, WM_DDE_TERMINATE,
                WM_DDE_TERMINATE, PM_REMOVE))
                break;
 
        DestroyWindow(hwnd);
        return 0;
 
    case WM_DESTROY:
        hPopAdvise = (GLOBALHANDLE)GetWindowLongPtr(hwnd, sizeof(DWORD));
        GlobalFree(hPopAdvise);
        return 0;
    }
    return DefWindowProc(hwnd, iMsg, 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;
    char         szPopulation[16];
    DDEACK       DdeAck;
    DDEDATA* pDdeData;
    DWORD        dwTime;
    GLOBALHANDLE hDdeData;
    MSG          msg;
    WORD         wStatus;
 
    aItem = GlobalAddAtomA(pop[iState].szState);
 
    // Allocate a DDEDATA structure if not deferred update
 
    if (fDeferUpd)
    {
        hDdeData = NULL;
    }
    else
    {
        wsprintfA(szPopulation, "%ld\r\n", pop[iState].lPop);
 
        hDdeData = GlobalAlloc(GHND | GMEM_DDESHARE,
            sizeof(DDEDATA) + strlen(szPopulation));
 
        pDdeData = (DDEDATA*)GlobalLock(hDdeData);
 
        pDdeData->fResponse = fResponse;
        pDdeData->fRelease = TRUE;
        pDdeData->fAckReq = fAckReq;
        pDdeData->cfFormat = CF_TEXT;
 
        lstrcpyA((PSTR)pDdeData->Value, szPopulation);
 
        GlobalUnlock(hDdeData);
    }
 
    // Post the WM_DDE_DATA iMsg
 
    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 iMsg if it's requested
 
    if (fAckReq)
    {
        DdeAck.fAck = FALSE;
 
        dwTime = GetCurrentTime();
 
        while (GetCurrentTime() - dwTime < DDE_TIMEOUT)
        {
            if (PeekMessage(&msg, hwndServer, WM_DDE_ACK, WM_DDE_ACK,
                PM_REMOVE))
            {
                UINT uiLow, uiHi;
                UnpackDDElParam(WM_DDE_ACK, msg.lParam, &uiLow, &uiHi);
                FreeDDElParam(WM_DDE_ACK, msg.lParam);
 
                wStatus = uiLow;
                DdeAck = *((DDEACK*)&wStatus);
                //aItem = HIWORD(msg.lParam);
                GlobalDeleteAtom((ATOM)uiHi);
                break;
            }
        }
 
        if (DdeAck.fAck == FALSE)
        {
            if (hDdeData != NULL)
                GlobalFree(hDdeData);
 
            //GlobalDeleteAtom(aItem);
            return FALSE;
        }
    }
 
    return TRUE;
}

/*---------------------------------------------------------------
   DDEPOP.H header file
 
   Data from "The World Almanac and Book of Facts 1992," page 75
  ---------------------------------------------------------------*/
 
#include <time.h>
 
struct
     {
     const char       *szState ;
     long        lPop70 ;
     long        lPop80 ;
     long        lPop90 ;
     long        lPop ;
     long        lPopLast ;
     long double a ;
     long double b ;
     long double c ;
     }
     pop[] = {
             "AL",   3444354,   3894025,   4040587, 0, 0, 0.0, 0.0, 0.0,
             "AK",    302583,    401851,    550043, 0, 0, 0.0, 0.0, 0.0,
             "AZ",   1775399,   2716546,   3665228, 0, 0, 0.0, 0.0, 0.0,
             "AR",   1923322,   2286357,   2350725, 0, 0, 0.0, 0.0, 0.0,
             "CA",  19971069,  23667764,  29760021, 0, 0, 0.0, 0.0, 0.0,
             "CO",   2209596,   2889735,   3294394, 0, 0, 0.0, 0.0, 0.0,
             "CT",   3032217,   3107564,   3287116, 0, 0, 0.0, 0.0, 0.0,
             "DE",    548104,    594338,    666168, 0, 0, 0.0, 0.0, 0.0,
             "DC",    756668,    638432,    606900, 0, 0, 0.0, 0.0, 0.0,
             "FL",   6791418,   9746961,  12937926, 0, 0, 0.0, 0.0, 0.0,
             "GA",   4587930,   5462982,   6478216, 0, 0, 0.0, 0.0, 0.0,
             "HI",    769913,    964691,   1108229, 0, 0, 0.0, 0.0, 0.0,
             "ID",    713015,    944127,   1006749, 0, 0, 0.0, 0.0, 0.0,
             "IL",  11110285,  11427409,  11430602, 0, 0, 0.0, 0.0, 0.0,
             "IN",   5195392,   5490214,   5544159, 0, 0, 0.0, 0.0, 0.0,
             "IA",   2825368,   2913808,   2776755, 0, 0, 0.0, 0.0, 0.0,
             "KS",   2249071,   2364236,   2477574, 0, 0, 0.0, 0.0, 0.0,
             "KY",   3220711,   3660324,   3685296, 0, 0, 0.0, 0.0, 0.0,
             "LA",   3644637,   4206116,   4219973, 0, 0, 0.0, 0.0, 0.0,
             "ME",    993722,   1125043,   1227928, 0, 0, 0.0, 0.0, 0.0,
             "MD",   3923897,   4216933,   4781468, 0, 0, 0.0, 0.0, 0.0,
             "MA",   5689170,   5737093,   6016425, 0, 0, 0.0, 0.0, 0.0,
             "MI",   8881826,   9262044,   9295297, 0, 0, 0.0, 0.0, 0.0,
             "MN",   3806103,   4075970,   4375099, 0, 0, 0.0, 0.0, 0.0,
             "MS",   2216994,   2520770,   2573216, 0, 0, 0.0, 0.0, 0.0,
             "MO",   4677623,   4916766,   5117073, 0, 0, 0.0, 0.0, 0.0,
             "MT",    694409,    786690,    799065, 0, 0, 0.0, 0.0, 0.0,
             "NE",   1485333,   1569825,   1578385, 0, 0, 0.0, 0.0, 0.0,
             "NV",    488738,    800508,   1201833, 0, 0, 0.0, 0.0, 0.0,
             "NH",    737681,    920610,   1109252, 0, 0, 0.0, 0.0, 0.0,
             "NJ",   7171112,   7365011,   7730188, 0, 0, 0.0, 0.0, 0.0,
             "NM",   1017055,   1303302,   1515069, 0, 0, 0.0, 0.0, 0.0,
             "NY",  18241391,  17558165,  17990455, 0, 0, 0.0, 0.0, 0.0,
             "NC",   5084411,   5880095,   6628637, 0, 0, 0.0, 0.0, 0.0,
             "ND",    617792,    652717,    638800, 0, 0, 0.0, 0.0, 0.0,
             "OH",  10657423,  10797603,  10847115, 0, 0, 0.0, 0.0, 0.0,
             "OK",   2559463,   3025487,   3145585, 0, 0, 0.0, 0.0, 0.0,
             "OR",   2091533,   2633156,   2842321, 0, 0, 0.0, 0.0, 0.0,
             "PA",  11800766,  11864720,  11881643, 0, 0, 0.0, 0.0, 0.0,
             "RI",    949723,    947154,   1003464, 0, 0, 0.0, 0.0, 0.0,
             "SC",   2590713,   3120729,   3486703, 0, 0, 0.0, 0.0, 0.0,
             "SD",    666257,    690768,    696004, 0, 0, 0.0, 0.0, 0.0,
             "TN",   3926018,   4591023,   4877185, 0, 0, 0.0, 0.0, 0.0,
             "TX",  11198655,  14225513,  16986510, 0, 0, 0.0, 0.0, 0.0,
             "UT",   1059273,   1461037,   1722850, 0, 0, 0.0, 0.0, 0.0,
             "VT",    444732,    511456,    562758, 0, 0, 0.0, 0.0, 0.0,
             "VA",   4651448,   5346797,   6187358, 0, 0, 0.0, 0.0, 0.0,
             "WA",   3413244,   4132353,   4866692, 0, 0, 0.0, 0.0, 0.0,
             "WV",   1744237,   1950186,   1793477, 0, 0, 0.0, 0.0, 0.0,
             "WI",   4417821,   4705642,   4891769, 0, 0, 0.0, 0.0, 0.0,
             "WY",    332416,    469557,    453588, 0, 0, 0.0, 0.0, 0.0,
             "US", 203302031, 226542203, 248709873, 0, 0, 0.0, 0.0, 0.0
             } ;
 
#define NUM_STATES (sizeof (pop) / sizeof (pop[0]))
 
void CalcPops (void)
     {
     int    i ;
     time_t lTime ;
 
     time (&lTime) ;                    // time in seconds since 1/1/70
     lTime -= 92L * 24 * 60 * 60 ;      // time in seconds since 4/1/70
 
     for (i = 0 ; i < NUM_STATES ; i++)
          pop[i].lPop = (long) (pop[i].a * lTime * lTime +
                                pop[i].b * lTime +
                                pop[i].c) ;
     }
 
void InitPops (void)
     {
     int         i ;
     long double ldSec80, ldSec90 ;
 
     ldSec80 = 3653.0 * 24 * 60 * 60 ;  // seconds from 4/1/70 to 4/1/80
     ldSec90 = 7305.0 * 24 * 60 * 60 ;  // seconds from 4/1/70 to 4/1/90
 
     for (i = 0 ; i < NUM_STATES ; i++)
          {
          pop[i].a = (ldSec90 * (pop[i].lPop80 - pop[i].lPop70) +
                      ldSec80 * (pop[i].lPop70 - pop[i].lPop90)) /
                     (ldSec90 * ldSec80 * (ldSec80 - ldSec90)) ;
 
          pop[i].b = (ldSec90 * ldSec90 * (pop[i].lPop70 - pop[i].lPop80) +
                      ldSec80 * ldSec80 * (pop[i].lPop90 - pop[i].lPop70)) /
                     (ldSec90 * ldSec80 * (ldSec80 - ldSec90)) ;
 
          pop[i].c = pop[i].lPop70 ;
          }
 
     CalcPops () ;
     }

/*----------------------------
   DDEPOP1.RC resource script
  ----------------------------*/
 
DdePop1 ICON ddepop.ico

/*-----------------------------------------
   SHOWPOP1.C -- DDE Client using DDEPOP1
                 (c) Charles Petzold, 1996
  -----------------------------------------*/
 
#include <windows.h>
#include <dde.h>
#include <stdlib.h>
#include <string.h>
#include "showpop.h"
 
#define WM_USER_INITIATE (WM_USER + 1)
#define DDE_TIMEOUT      3000
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
char szAppName[] = "ShowPop1";
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    PSTR szCmdLine, int iCmdShow)
{
    HWND       hwnd;
    MSG        msg;
    WNDCLASSEXA wndclass;
 
    wndclass.cbSize = sizeof(wndclass);
    wndclass.style = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc = WndProc;
    wndclass.cbClsExtra = 0;
    wndclass.cbWndExtra = 0;
    wndclass.hInstance = hInstance;
    wndclass.hIcon = LoadIconA(hInstance, szAppName);
    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wndclass.lpszMenuName = NULL;
    wndclass.lpszClassName = szAppName;
    wndclass.hIconSm = LoadIconA(hInstance, szAppName);
 
    RegisterClassExA(&wndclass);
 
    hwnd = CreateWindowA(szAppName, "DDE Client - US Population",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, hInstance, NULL);
 
    ShowWindow(hwnd, iCmdShow);
    UpdateWindow(hwnd);
 
    SendMessage(hwnd, WM_USER_INITIATE, 0, 0L);
 
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}
 
LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
    static BOOL   fDoingInitiate = TRUE;
    static char   szServerApp[] = "DdePop1",
        szTopic[] = "US_Population";
    static HWND   hwndServer = NULL;
    static long   cxChar, cyChar;
    ATOM          aApp, aTop, aItem;
    char          szBuffer[24], szPopulation[16], szItem[16];
    DDEACK        DdeAck;
    DDEDATA* pDdeData;
    DDEADVISE* pDdeAdvise;
    DWORD         dwTime;
    GLOBALHANDLE  hDdeAdvise, hDdeData;
    HDC           hdc;
    MSG           msg;
    PAINTSTRUCT   ps;
    int           i;
    long          x, y;
    TEXTMETRIC    tm;
    WORD          wStatus;
    UINT          uiLow, uiHi;
 
    switch (iMsg)
    {
    case WM_CREATE:
        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 = GlobalAddAtomA(szServerApp);
        aTop = GlobalAddAtomA(szTopic);
 
        SendMessage(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwnd,
            MAKELONG(aApp, aTop));
 
        // If no response, try loading DDEPOP first
 
        if (hwndServer == NULL)
        {
            //WinExec(szServerApp, SW_SHOWMINNOACTIVE);
            SHELLEXECUTEINFOA shinf;
            shinf.cbSize = sizeof(SHELLEXECUTEINFO);
            shinf.fMask = NULL;
            shinf.hwnd = NULL;
            shinf.lpVerb = NULL;
            shinf.lpFile = szServerApp;
            shinf.lpParameters = NULL;
            shinf.lpDirectory = NULL;
            shinf.nShow = SW_SHOWMINNOACTIVE;
            shinf.hInstApp = NULL;
 
            ShellExecuteExA(&shinf);
 
            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)
        {
            MessageBoxA(hwnd, "Cannot connect with DDEPOP1.EXE!",
                szAppName, MB_ICONEXCLAMATION | MB_OK);
 
            return 0;
        }
 
        // Post WM_DDE_ADVISE iMsgs
 
        for (i = 0; i < NUM_STATES; i++)
        {
            hDdeAdvise = GlobalAlloc(GHND,
                sizeof(DDEADVISE));
 
            if (!hDdeAdvise)
            {
                MessageBox(hwnd, TEXT("GlobalAlloc failure"),
                    TEXT("ERROR: WM_USER_INITIATE"),
                    MB_OK);
                break;
            }
 
            pDdeAdvise = (DDEADVISE*)GlobalLock(hDdeAdvise);
            if (!pDdeAdvise)
            {
                MessageBox(hwnd, TEXT("GlobalLock failure"),
                    TEXT("ERROR: WM_USER_INITIATE"),
                    MB_OK);
                break;
            }
            pDdeAdvise->reserved = 0;
            pDdeAdvise->fAckReq = TRUE;
            //pDdeAdvise->fAckReq = FALSE;
            pDdeAdvise->fDeferUpd = FALSE;
            pDdeAdvise->cfFormat = CF_TEXT;
 
            GlobalUnlock(hDdeAdvise);
 
            aItem = GlobalAddAtomA(pop[i].szAbb);
 
            if (!PostMessage(hwndServer, WM_DDE_ADVISE, (WPARAM)hwnd,
                PackDDElParam(WM_DDE_ADVISE,
                    (UINT_PTR)hDdeAdvise, aItem)))
            {
                GlobalFree(hDdeAdvise);
                GlobalDeleteAtom(aItem);
                FreeDDElParam(WM_DDE_ADVISE, lParam);
                break;
            }
 
            DdeAck.fAck = FALSE;
 
            dwTime = GetCurrentTime();
 
            while (GetCurrentTime() - dwTime < DDE_TIMEOUT)
            {
                if (PeekMessage(&msg, hwnd, WM_DDE_ACK,
                    WM_DDE_ACK, PM_REMOVE))
                {
                    UnpackDDElParam(WM_DDE_ACK, msg.lParam, &uiLow, &uiHi);
                    FreeDDElParam(WM_DDE_ACK, msg.lParam);
 
                    GlobalDeleteAtom((ATOM)uiHi);
 
                    wStatus = uiLow;
                    DdeAck = *((DDEACK*)&wStatus);
 
                    if (DdeAck.fAck == FALSE)
                        GlobalFree(hDdeAdvise);
 
                    break;
                }
            }
 
            if (DdeAck.fAck == FALSE)
                break;
 
            while (PeekMessage(&msg, hwnd, WM_DDE_FIRST,
                WM_DDE_LAST, PM_REMOVE))
            {
                DispatchMessage(&msg);
            }
        }
 
        if (i < NUM_STATES)
        {
            MessageBoxA(hwnd, "Failure on WM_DDE_ADVISE!",
                szAppName, MB_ICONEXCLAMATION | MB_OK);
        }
        return 0;
 
    case WM_DDE_ACK:
 
        // In response to WM_DDE_INITIATE, save server window
 
        if (fDoingInitiate)
        {
            //UnpackDDElParam(WM_DDE_ACK, lParam, &uiLow, &uiHi);
            //FreeDDElParam(WM_DDE_ACK, lParam);
            uiLow = LOWORD(lParam); 
            uiHi  = HIWORD(lParam);
            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
 
        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_TEXT)
        {
            GlobalGetAtomNameA(aItem, szItem, sizeof(szItem));
 
            for (i = 0; i < NUM_STATES; i++)
                if (strcmp(szItem, pop[i].szAbb) == 0)
                    break;
 
            if (i < NUM_STATES)
            {
                strcpy_s(szPopulation, 16, (char*)pDdeData->Value);
                pop[i].lPop = atol(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:
        hdc = BeginPaint(hwnd, &ps);
 
        for (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;
            }
 
            TextOutA(hdc, x, y, szBuffer,
                wsprintfA(szBuffer, "%-20s",
                    (PSTR)pop[i].szState));
 
            x += 36 * cxChar;
 
            SetTextAlign(hdc, TA_RIGHT | TA_TOP);
 
            TextOutA(hdc, x, y, szBuffer,
                wsprintfA(szBuffer, "%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_TEXT, NULL));
 
        dwTime = GetCurrentTime();
 
        while (GetCurrentTime() - dwTime < DDE_TIMEOUT)
        {
            if (PeekMessage(&msg, 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(&msg, hwnd, WM_DDE_TERMINATE,
                WM_DDE_TERMINATE, PM_REMOVE))
                break;
        }
 
        break;             // for default processing
 
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc(hwnd, iMsg, wParam, lParam);
}