ddepop1.c

ProgrammingWindowSourceCode

                                           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_TEXT || cfFormat == NULL)
                    {
                    if (aItem == (ATOM) NULL)
                         for (i = 0 ; i < NUM_STATES ; i++)
                              pPopAdvise[i].fAdvise = FALSE ;
                    else
                         {
                         GlobalGetAtomName (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) GetWindowLong (hwnd, 0) ;
               hPopAdvise = (GLOBALHANDLE) GetWindowLong (hwnd, 4) ;
               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) GetWindowLong (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) GetWindowLong (hwnd, 4) ;
               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 = GlobalAddAtom (pop[iState].szState) ;

          // Allocate a DDEDATA structure if not deferred update

     if (fDeferUpd)
          {
          hDdeData = NULL ;
          }
     else
          {
          wsprintf (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 ;

          lstrcpy ((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))
                    {
                    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 ;
     }