You need to create a number of variables
HANDLE ghMyInstance; //my instance, simple
short gnMyInstanceCount; //2 bytes
HWND hwndMain; //the main visible window
HWND hwndDDE; //The invisible DDE window.
HWND hwndMyContact; //the DDE window our DDE window talks to
BOOL bTerminating; //Boolean. Any number of bytes.
BOOL bAlreadyConversing; //Tre or False, whether or not we are already playing
ATOM atomPlayerNotReady; //atom
ATOM atomPlayerReady; //atom
ATOM atomMyName; //atom
ATOM atomNewHeartsPlayer; //atom
HANDLE hDDEInformation; //Handle to a Globally allocated memory, allocated by dealer.
You need a number of core functions to get off the ground
int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpCmdLine, int nCmdShow);
long FAR PASCAL MainWndProc (HWND, unsigned, WORD, LONG);
long FAR PASCAL DDEWndProc (HWND, unsigned, WORD, LONG);
BOOL InitApplication (HANDLE);
void UnInitApplication ();
BOOL InitInstance (HANDLE,HANDLE, int);
BOOL FAR PASCAL AboutDlgProc (HWND, unsigned, WORD, LONG);
char* ConvertCardToText (cardtype* cardToConvert, char* szResultText);
short ProcessInitiate (HWND hwnd, unsigned message, WORD wParam, LONG lParam);
short ProcessTermination (HWND hwnd, unsigned message, WORD wParam, LONG lParam);
short ProcessDealerMessage (HWND hwnd, unsigned message, WORD wParam, LONG lParam);
void CauseConversationTermination(short bMakeSelfAvailableAgain);
This is what each of the functions need to do.
int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpCmdLine, int nCmdShow){
// All you have to do is simply initialize your code.
// Create the main window and the DDE window.
// Run the message loop
//
//example C code.
MSG msg;
if(!hPrevInstance){
if(!InitApplication(hInstance))
return (FALSE);
}
if(!InitInstance(hInstance, hPrevInstance, nCmdShow))
return (FALSE);
while (GetMessage(&msg, NULL, NULL, NULL)){
TranslateMessage(&msg);
DispatchMessage(&msg);
}
UnInitApplication();
return (msg.wParam);
}
BOOL InitApplication(HANDLE hInstance){
// If there was no previous instance of this program, then call this function.
// Register the main window and DDE window classes.
//example C code
WNDCLASS wc;
wc.style = NULL;
wc.lpfnWndProc = (long(pascal*)(unsigned int,unsigned int,unsigned int,long))MainWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = 0;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = SZ_CLIENT_WINDOW_CLASS;
wc.lpszClassName = SZ_CLIENT_WINDOW_CLASS;
if(!RegisterClass(&wc))
return FALSE;
wc.style = NULL;
wc.lpfnWndProc = (long(pascal*)(unsigned int,unsigned int,unsigned int,long))DDEWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = SZ_CLIENT_DDE_WINDOW_CLASS;
return RegisterClass(&wc);
}
BOOL InitInstance(HANDLE hInstance, HANDLE hPrevInstance, int nCmdShow){
//Create the two windows, the main and DDE windows.
//Show the main window.
//Create the four necessary atoms.
//Send a message to all 'overlapped' windows telling them we are here.
//In the example code, we get the count of ourselves by asking any previous
// instance what its count was. This is useful if we want to play two or
// more of them at the same time. Giving ourselves a count makes it easier
// to identify which player is which.
//example C code
HDC hDC;
ghMyInstance = hInstance;
hwndMain = CreateWindow(SZ_CLIENT_WINDOW_CLASS,SZ_CLIENT_WINDOW_NAME,
WS_OVERLAPPEDWINDOW,100,100,100,100, //Height
NULL,NULL,hInstance,NULL);
if(!hwndMain)
return FALSE;
ShowWindow(hwndMain, nCmdShow);
hwndDDE = CreateWindow(SZ_CLIENT_DDE_WINDOW_CLASS,
SZ_CLIENT_DDE_WINDOW_NAME,
WS_OVERLAPPED,0,0,1,1,NULL,NULL,hInstance, NULL);
if(!hwndDDE){
DestroyWindow(hwndMain);
return FALSE;
}
if(hPrevInstance)
gnMyInstanceCount =SendMessage(hPrevInstance,WM_WHATS_YOUR_INSTANCE_COUNT, 0, 0L)+1;
if(gnMyInstanceCount>0) //only put this count if there is more than a single instance of me.
wsprintf(ATOM_MY_NAME+N_ATOM_MY_NAME, "%d",gnMyInstanceCount+1); //'+1' converts to 1-based counting
atomPlayerNotReady =GlobalAddAtom(ATOM_TOPIC_YOUR_CONTACT);
atomPlayerReady =GlobalAddAtom(ATOM_TOPIC_PLAYER_READY);
atomMyName =GlobalAddAtom(ATOM_MY_NAME);
atomNewHeartsPlayer=GlobalAddAtom(ATOM_TOPIC_NEW_HEARTS_PLAYER);
//We send out a message to everyone (especially any Hearts games playing) that we are here.
SendMessage(SEND_TO_ALL_WINDOWS, HM_INITIATE_CONVERSATION, hwndDDE, MAKELONG(atomMyName,atomNewHeartsPlayer));
return TRUE;
}
void UnInitApplication(){
//This is called when the user quits the external player application.
//If we are still in a game with the dealer, then 'cause it to stop'
//destroy the DDE window. We don't destroy the main window here becuase
// presumably the destruction of it by other means is what caused this
// function to be called.
//Delete the four all-important atoms.
//example C code.
if(bAlreadyConversing)
CauseConversationTermination(FALSE);
if(hwndDDE)
DestroyWindow(hwndDDE);
GlobalDeleteAtom(atomPlayerNotReady);
GlobalDeleteAtom(atomPlayerReady);
GlobalDeleteAtom(atomMyName);
GlobalDeleteAtom(atomNewHeartsPlayer);
}
long FAR PASCAL MainWndProc(HWND hwnd, unsigned message, WORD wParam, LONG lParam){
//This is our main window procedure.
//We don't do anything unusual here except respond to the WM_WHATS_YOUR_INSTANCE_COUNT
// message and call the 'CauseConversationTermination()' function in the
// WM_DESTROY message.
//example C code
PAINTSTRUCT paintstructTemp;
HDC hdcTemp;
FARPROC procAboutBox;
switch (message){
case WM_PAINT:
hdcTemp = BeginPaint(hwnd, &paintstructTemp);
//Put whatever you want here.
EndPaint(hwnd, &paintstructTemp);
break;
case WM_DESTROY:
bTerminating = TRUE;
CauseConversationTermination(FALSE); //Save This Function Call.
PostQuitMessage(0);
break;
case WM_COMMAND:
switch (wParam){
case ID_ABOUT:
procAboutBox = MakeProcInstance((FARPROC)AboutDlgProc, ghMyInstance);
if(procAboutBox){
DialogBox(ghMyInstance, SZ_ABOUT_DIALOG_NAME, hwndMain, procAboutBox);
FreeProcInstance(procAboutBox);
}
break;
case ID_QUIT:
PostQuitMessage(0);
break;
case ID_END_PLAY:
CauseConversationTermination(TRUE);
break;
}
break;
case WM_WHATS_YOUR_INSTANCE_COUNT:
return gnMyInstanceCount;
default:
return DefWindowProc(hwnd, message, wParam, lParam);
}
return 1L;
}
BOOL FAR PASCAL AboutDlgProc(HWND hDlg, unsigned message, WORD wParam, LONG lParam){
//This is the 'About' dialog procedure. You may want to make an 'About box' that
// gives some information about the external player. Then give it an OK button
//example C code
switch (message) {
case WM_INITDIALOG:
return TRUE;
case WM_COMMAND:
if(wParam == IDOK || wParam == IDCANCEL) {
EndDialog(hDlg, TRUE);
return TRUE;
}
break;
}
return FALSE;
}
long FAR PASCAL DDEWndProc(HWND hwnd, unsigned message, WORD wParam, LONG lParam){
//This is the DDE window's procedure. It must respond to the three important
// DDE messages from the dealer. It doesn't need to paint becuase it is invisible.
// Each of the three messages from the dealer have an associated function that
// we call. See the example below.
//example C code
switch (message){
case HM_INITIATE_CONVERSATION: //(same as WM_DDE_INITIATE)
return ProcessInitiate(hwnd, message, wParam, lParam);
case HM_TERMINATE_CONVERSATION: //(same as WM_DDE_TERMINATE)
return ProcessTermination(hwnd, message, wParam, lParam);
case HM_DLR_PROCESS_THIS_MESSAGE: //(same as WM_DDE_DATA)
return ProcessDealerMessage(hwnd, message, wParam, lParam);
default:
return DefWindowProc(hwnd, message, wParam, lParam);
}
}
short ProcessInitiate(HWND hwnd, unsigned message, WORD wParam, LONG lParam){
//This is called from the DDE window procedure. There are two types of
// initiate messages, one for the NEW_GAME, and one for a NEW_CONTACT. See
// the documentation for the description of the initiation procedure.
//Essentially, we must see if it is a new game initiation. If so then
// ignore it if we are already playing. Also, ignore the message if it is
// coming from ourselves. The HWND sending is in the wParam of the message.
//If it is a NEW_CONTACT message, then if we are not already playing with
// another dealer, set the contact HWND (in wParam) to be our contact.
//Send acknowledgment messages back if OK in both cases.
//example C code
char szAtomText[256];
WORD wApplication=LOWORD(lParam);
WORD wTopic =HIWORD(lParam);
if(wParam == hwndDDE) //Return if the sender is myself.
return NOT_OK;
GlobalGetAtomName(wTopic, szAtomText, 255);
if(!lstrcmp(szAtomText, ATOM_TOPIC_NEW_HEARTS_GAME)){
if(!bAlreadyConversing){
//Send message back to the sender that we can converse with him.
SendMessage((HWND)wParam, HM_ACKNOWLEDGEMENT, hwndDDE, MAKELONG(atomMyName, wTopic));
return OK;
}
//otherwise ignore the initiation, we are busy already with someone else
}
else if(!lstrcmp(szAtomText,ATOM_TOPIC_YOUR_CONTACT)){
//This means that we are being called into the conversation for good.
if(!bAlreadyConversing){
bAlreadyConversing =TRUE;
hwndMyContact=(HWND)wParam;
SendMessage((HWND)wParam, HM_ACKNOWLEDGEMENT, hwndDDE, MAKELONG(atomMyName, atomPlayerReady));
return OK;
}
else{
return NOT_OK;
}
}
//Otherwise we cannot be a client for the message sender.
return NOT_OK;
}
short ProcessTermination(HWND hwnd, unsigned message, WORD wParam, LONG lParam){
//We are being told to terminate.
//This means our conversation is over and we can prepare to make a conversation
// with someone else if they ask.
//All we have to do is set everything to zero. Since the Contact told us to close, we
// don't have to send it anything back.
//example C code
hwndMyContact =
hDDEInformation =
bTerminating =
bAlreadyConversing =0;
return OK;
}
void CauseConversationTermination(short bMakeSelfAvailableAgain){
//Tell the contact that we are OUTTA HERE.
//Don't tell anyone unless we are actually in a conversation with them.
//example C code
if(bAlreadyConversing){
PostMessage(hwndMyContact, HM_TERMINATE_CONVERSATION, hwndDDE, 0L);
}
hwndMyContact =0; //Not necessary if we are closing our app, of course.
bTerminating =0;
bAlreadyConversing =0;
hDDEInformation =0;
if(bMakeSelfAvailableAgain)
SendMessage(SEND_TO_ALL_WINDOWS, HM_INITIATE_CONVERSATION, hwndDDE, MAKELONG(atomMyName,atomNewHeartsPlayer));
}
short ProcessDealerMessage(HWND hwnd, unsigned message, WORD wParam, LONG lParam){
//loword is hData, hiword is atomItem. Same as WM_DDE_DATA.
//This function is the main card playing function of importance.
//There should be a function (or equivalent) for each message from the dealer
// that you want to respond to. You MUST respond to the 5 required messages.
// You don't have to respond to the other 'notify' messages.
//You want to first make sure the message sender is your contact.
//Then lock the global memory share so you can read the message.
//Then test if it is a notify message. If so then do what you want with it.
//If instead it is a 'your turn' message, then you must call functions to
// come up with your answer and put your answer into the appropriate place
// in the global share and then return to this function and post your
// answer message to the dealer.
//Below the example code shows everything except the filling in of the
// global share with the answer.
//example C code.
MessageStruct far* messageStructFromDealer;
short i;
char szAtomText[256];
WORD hData =LOWORD(lParam);
WORD wTopic=HIWORD(lParam);
if(wParam != hwndMyContact)
return NOT_OK;
if(!hDDEInformation)
hDDEInformation = LOWORD(lParam);
if(!hDDEInformation)
return NOT_OK;
messageStructFromDealer = (MessageStruct far*) GlobalLock(hDDEInformation);
GlobalGetAtomName(wTopic, szAtomText, 255);
if(!lstrcmp(szAtomText, ATOM_TOPIC_NOTIFY)){
//Call a function(s) here to process the notification.
}
else if(!lstrcmp(szAtomText, ATOM_TOPIC_YOUR_TURN)){
//Call a function here depending on exactly which message was sent.
//The global storage should be filled in with the answer.
//Call the all important functions here.
if(nearMessageStruct.nQueryMessage == P_DO_PASS ||
nearMessageStruct.nQueryMessage == P_LEAD_CARD ||
nearMessageStruct.nQueryMessage == P_PLAY_CARD ||
nearMessageStruct.nQueryMessage == P_REGISTER_PLAYER)
{
messageStructFromDealer->nReturnMessage = messageStructFromDealer->nQueryMessage;
//In this case we must send our answer back to the dealer.
//For this PostMessage, loword is hData and hiword is atomItem. Same as sending WM_DDE_POKE.
//Normally, in DDE, we put the anwser (hData) in LOWORD(lParam) and topic in HIWORD(lParam)
// Since these values are already known by both parties, this is not necessary.
PostMessage(hwndMyContact, HM_PLR_HERE_IS_MY_ANSWER, hwndDDE, 0L);
} //same as WM_DDE_POKE
}
GlobalUnlock(hDDEInformation);
return OK;
}
char* ConvertCardToText(cardtype* cardToConvert, char* szResultText){
//This function is not necessary but may be useful for debugging. It
// converts a 'cardtype' (see external.txt/doc) to a text string for
// display (possibly in the main window) to show at run-time. Since
// DDE is a real-time system, you cannot sit in a debugger while the
// messages are trying to be passed around and time-outs are happening.
//example C code
//The return is a pointer to the 'szResultText'
//The result text is an array of characters (min of 4) to be filled in with the text.
//The card text is in the format of: 10H, JD, QS, 4C, 9H, AD, etc.
char szSuitChars[4][2] = {"S","D","C","H"};
char szNumberChars[13][3] = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
lstrcpy(szResultText,szNumberChars[cardToConvert->kind.number-2]);
lstrcat(szResultText,szSuitChars[cardToConvert->kind.suit-1]);
return szResultText;
}