Click here to Skip to main content
15,867,308 members
Please Sign up or sign in to vote.
0.00/5 (No votes)
See more:
Hitting the PostMessage command , but unable to go inside the wndProc for that posted message.

What I have tried:

// PostThreadMessageNature.cpp : Defines the entry point for the application.
//

#include "framework.h"
#include "CombinedPostMessageAndPostThreadMessageNature.h"
#include <string>

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE hInst;                                // current instance
WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name

// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

/******************************************************************************
Required Declaration
******************************************************************************/

#define  WM_MSGSSENTVIAPOSTMSG     WM_USER+ 1
#define  WM_MSGSSENTVIAPOSTTHREADMSG     WM_USER+ 2

DWORD MainThreadID;
HWND MainWnd;

/******************************************************************************
For Post Thread Message
******************************************************************************/
bool PostThreadMessageWantToHandledByWndProc = true;//false;
bool PostThreadMessageWantToHandledManually = false;// true;


void CreateUserThread(DWORD);
void SendMessageFromAnotherThread(LPVOID);
void PostThreadMessageMessageHandlerViaWndProc();
void PostThreadMessageMessageHandlerViaManually();

void RedirectorForPostThreadMessageMessageHandlerViaWndProc(MSG);
void RedirectorForPostThreadMessageMessageHandlerViaManually(MSG);


/******************************************************************************
For Post Message
******************************************************************************/

void GeneratePostMessage();

void PostMessageMessageHandlerViaWndProc();

void SendPostMessageWithNullWndHandle();


/******************************************************************************
NOT WORKING, DONT KNOW WHY????
******************************************************************************/



int APIENTRY wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

	// TODO: Place code here.

	// Initialize global strings
	LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadStringW(hInstance, IDC_COMBINEDPOSTMESSAGEANDPOSTTHREADMESSAGENATURE, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Perform application initialization:
	if (!InitInstance(hInstance, nCmdShow))
	{
		return FALSE;
	}

	MainThreadID = GetCurrentThreadId();
	CreateUserThread(MainThreadID);

	HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_COMBINEDPOSTMESSAGEANDPOSTTHREADMESSAGENATURE));

	MSG msg;

	/******************************************************************************
	*If hWnd is - 1, GetMessage retrieves only messages on the current thread's message
	 queue whose hwnd value is NULL, that is, thread messages as posted by PostMessage
	 (when the hWnd parameter is NULL) or PostThreadMessage.
	******************************************************************************/
	HWND hWndThread = (HWND)(-1);


	// Main message loop:
	while (GetMessage(&msg, hWndThread, 0, 0))
	{
		if (PostThreadMessageWantToHandledByWndProc)
		{
			RedirectorForPostThreadMessageMessageHandlerViaWndProc(msg);
			PostThreadMessageWantToHandledByWndProc = false;
			PostThreadMessageWantToHandledManually = false;
		}
		else if (PostThreadMessageWantToHandledManually)
		{
			RedirectorForPostThreadMessageMessageHandlerViaManually(msg);
		}
		else
		{
			if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
	}

	return (int)msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEXW wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style = CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc = WndProc;
	wcex.cbClsExtra = 0;
	wcex.cbWndExtra = 0;
	wcex.hInstance = hInstance;
	wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_COMBINEDPOSTMESSAGEANDPOSTTHREADMESSAGENATURE));
	wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
	wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
	wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_COMBINEDPOSTMESSAGEANDPOSTTHREADMESSAGENATURE);
	wcex.lpszClassName = szWindowClass;
	wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	return RegisterClassExW(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
	hInst = hInstance; // Store instance handle in our global variable

	HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

	if (!hWnd)
	{
		return FALSE;
	}
	MainWnd = hWnd;
	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);

	return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_COMMAND:
	{
		int wmId = LOWORD(wParam);
		// Parse the menu selections:
		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
	}
	break;
	case WM_PAINT:
	{
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(hWnd, &ps);
		// TODO: Add any drawing code that uses hdc here...
		EndPaint(hWnd, &ps);
	}
	break;
	case WM_MSGSSENTVIAPOSTTHREADMSG:
	{
		PostThreadMessageMessageHandlerViaWndProc();
		GeneratePostMessage();
		break;
	}
	
	case WM_MSGSSENTVIAPOSTMSG:
	{
		PostMessageMessageHandlerViaWndProc();
		break;
	}
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;

	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}


void CreateUserThread(DWORD mainThreadID)
{
	DWORD threadID = 0;
	HANDLE hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SendMessageFromAnotherThread, (LPVOID)mainThreadID, 0, &threadID);

	if (hThread)
	{
		WaitForSingleObject(hThread, (DWORD)INFINITY);
		return;
	}
}

void SendMessageFromAnotherThread(LPVOID mainThreadID)
{
	DWORD l_mainThreadID = (DWORD)mainThreadID;
	Sleep(100);
	PostThreadMessage(l_mainThreadID, WM_MSGSSENTVIAPOSTTHREADMSG, 0, 0);
}

void PostThreadMessageMessageHandlerViaWndProc()
{
	MessageBox(NULL, L"Thread Message Sent Using PostThreadMessage", L" Thread Message Handled from WndProc", MB_ICONINFORMATION);
}

void PostThreadMessageMessageHandlerViaManually()
{
	MessageBox(NULL, L"Thread Message Sent Using PostThreadMessage", L" Thread Message Handled Manually", MB_ICONINFORMATION);
}

void RedirectorForPostThreadMessageMessageHandlerViaWndProc(MSG msg)
{
	if (msg.message == WM_MSGSSENTVIAPOSTTHREADMSG)
	{
		msg.hwnd = MainWnd;
		DispatchMessage(&msg);
	}
}
void RedirectorForPostThreadMessageMessageHandlerViaManually(MSG msg)
{
	if (msg.message == WM_MSGSSENTVIAPOSTTHREADMSG)
	{
		PostThreadMessageMessageHandlerViaManually();
	}
}

void GeneratePostMessage()
{
	SendPostMessageWithNullWndHandle();
}

void PostMessageMessageHandlerViaWndProc()
{
	MessageBox(NULL, L"Message Received from Post Message to a NULL Window(In The Current Thread)", L"MessageReceivedFromPostMessage", MB_ICONINFORMATION);
	PostQuitMessage(0);
}

void SendPostMessageWithNullWndHandle()
{
	MessageBox(NULL, L"Sending Message to a NULL Window(In The Current Thread)", L"PostMessageUsingPostMessage", MB_ICONINFORMATION);
	Sleep(100);
	auto lTime = GetCurrentTime();
	PostMessage(NULL, WM_MSGSSENTVIAPOSTMSG, 0, lTime);
}
Posted
Comments
Richard MacCutchan 28-Sep-22 6:41am    
You need to add some more detail to your question. There is far too much code there to be able to guess where the problem occurs, let alone what may be the answer.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)



CodeProject, 20 Bay Street, 11th Floor Toronto, Ontario, Canada M5J 2N8 +1 (416) 849-8900