Broadcasting to owned window with PostMessage vs. SendNotifyMessage

Question

Recently I came about a strange difference between the two Win32 API calls "PostMessage" and "SendNotifyMessage" (at least noticed on Win7 64bit SP1): An owned top-level window of another process seems not to receive messages broadcasted (HWND_BROADCAST) with "PostMessage" while it receives messages broadcasted with "SendNotifyMessage" in its WndProc.

The sent message have been registered with the help of a call to "RegisterWindowMessage".

Even using Spy++, I cannot see the message arriving when using "PostMessage". In addition, I want to mention, that if I send the message directly to the specific HWND with "PostMessage", it arrives as expected. So it looks like the windows-internal implementation of "PostMessage" just skips my window when iterating for execution of the broadcast.

Reading the respective MSDN documentation, I cannot see any statement about this difference and I am wondering if this is a bug in PostMessage or in SendNotifyMessage and if I can rely on SendNotifyMessage to continue to show this behavior in future versions of Windows.

So does someone have a plausible explanation why the both functions treat the broadcasts differently in this situation?

In addition, I would want to ask if there is any way to still use PostMessage to broadcast to an owned top-level window, because I would prefer to post the message because I would prefer to not skip the message queue (which is what SendNotifyMessage does).

In case you are curious why I want to reach a top-level owned window: in WPF, windows are hidden from the taskbar (Window.ShowInTaskbar property) by making them owned top-level windows with a hidden owner window.

Thanks a lot in advance for any ideas or comments on this topic.

Attachment: here a sample showing the behavior ... simply build it, and start it two times ... the second process should make a message show up in the first one. Here is also a link to the complete solution including a build EXE: Link to the complete VS solution

#include <windows.h>
#include <stdio.h>

#include <string>
#include <vector>


HWND hwndMain = NULL;
HWND ownerHwnd = NULL;

std::vector<std::string> theOutput;
UINT MyRegisteredMessage1 = 0;


LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  PAINTSTRUCT ps;
  HDC hdc = NULL;

  if (message == MyRegisteredMessage1 && wParam != (WPARAM) hwndMain)
  {
    if (lParam == (LPARAM) 1)
      theOutput.push_back("Got a 'MyRegisteredMessage1' via PostMessage");
    if (lParam == (LPARAM) 2)
      theOutput.push_back("Got a 'MyRegisteredMessage1' via SendNotifyMessage");

    InvalidateRect(hwndMain, NULL, TRUE);
  }

  switch (message) 
  {
  case WM_PAINT:
    hdc = BeginPaint(hWnd, &ps);
    for(size_t i = 0, pos = 0; i < theOutput.size(); ++i, pos += 20)
      TextOutA(hdc, 0, pos, theOutput[i].c_str(), theOutput[i].size());
    EndPaint (hWnd, &ps);
    break;

  case WM_DESTROY:
    PostQuitMessage(0);
    break;

  default:
    return DefWindowProc(hWnd, message, wParam, lParam);
  }

  return 0;
}


LRESULT CALLBACK WndProcHidden(HWND hWnd, UINT message,
  WPARAM wParam, LPARAM lParam)
{
    return DefWindowProc(hWnd, message, wParam, lParam);
}


int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
  LPSTR lpszCmdLine, int nCmdShow) 
{
  MSG msg;
  BOOL bRet; 
  WNDCLASSA wc; 
  UNREFERENCED_PARAMETER(lpszCmdLine); 

  if (!hPrevInstance) 
  { 
    wc.style = 0; 
    wc.lpfnWndProc = (WNDPROC) WndProcHidden; 
    wc.cbClsExtra = 0; 
    wc.cbWndExtra = 0; 
    wc.hInstance = hInstance; 
    wc.hIcon = LoadIcon((HINSTANCE) NULL, IDI_APPLICATION); 
    wc.hCursor = LoadCursor((HINSTANCE) NULL, IDC_ARROW); 
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);;
    wc.lpszMenuName =  "MainMenu"; 
    wc.lpszClassName = "MyOwnerWindowClass"; 

    if (!RegisterClassA(&wc)) 
      return FALSE;

    wc.lpfnWndProc = (WNDPROC) WndProc; 
    wc.lpszClassName = "MyOwnedWindowClass"; 

    if (!RegisterClassA(&wc)) 
      return FALSE; 
  } 

  ownerHwnd = CreateWindowA("MyOwnerWindowClass", "OwnerWindow", 
    WS_OVERLAPPEDWINDOW, 0, 0, 800, 400, (HWND) NULL, 
    (HMENU) NULL, hInstance, (LPVOID) NULL); 

  hwndMain = CreateWindowA("MyOwnedWindowClass", "OwnedWindow", 
    WS_OVERLAPPEDWINDOW, 0, 0, 800, 400, ownerHwnd, 
    (HMENU) NULL, hInstance, (LPVOID) NULL); 

  // only show the "real" window
  ShowWindow(hwndMain, nCmdShow); 
  UpdateWindow(hwndMain); 

  MyRegisteredMessage1 = RegisterWindowMessageA("MyRegisteredMessage1");

  char infoText[256];
  _snprintf_s(infoText, 256,
    "HWND = %X, registered message code for 'MyRegisteredMessage1' = %d",
    hwndMain, MyRegisteredMessage1);
  theOutput.push_back(infoText);
  InvalidateRect(hwndMain, NULL, TRUE);

  PostMessage(HWND_BROADCAST, MyRegisteredMessage1, (WPARAM) hwndMain, (LPARAM) 1);
  Sleep(1000);
  SendNotifyMessageA(HWND_BROADCAST, MyRegisteredMessage1, (WPARAM) hwndMain, (LPARAM) 2);


  while( (bRet = ::GetMessage( &msg, NULL, 0, 0 )) != 0)
  {
      TranslateMessage(&msg); 
      DispatchMessage(&msg); 
  } 

  return msg.wParam; 
} 

Answer 1

Just adding this here for info..

I was able to get around this issue in c# by registering an IMessageFilter object on the Application level. PreFilterMessage on this object will receive the message and I can handle it from there.

public class FooMessageFilter : IMessageFilter
{
    uint UM_FOO = 0;
    public event EventHandler OnFoo;
    
    public FooMessageFilter()
    {
        UM_FOO = Win32.RegisterWindowMessage("UM_FOO");
    }

    public bool PreFilterMessage(ref Message m)
    {
        if(m.Msg == UM_FOO)
        {
            if(OnFoo != null)
                OnFoo(this, new EventArgs());
                
            return true;
        }

        return false;
    }
}

I then added this message filter to the Application context in my owned top-level form's constructor.

public partial class Form1 : Form
{
    private FooMessageFilter fooFilter = new FooMessageFilter();
    public Form1()
    {
        InitializeComponent();
        
        // Register message filter
        Application.AddMessageFilter(fooFilter);
        
        // Subscribe to event
        fooFilter.OnFoo += HandleFoo;
    }
    
    private void HandleFoo(object o, EventArgs e)
    {
        MessageBox.Show("Foo!");
    }
}

From there it was just a matter of hooking up events in my top-level window to the message filter. This was necessary because of the need to adhere to current architecture, and the message originating from a third party process.

Answer 2

The documentation page(s) for PostMessage() mention that integrity level restrictions apply:

Starting with Windows Vista, message posting is subject to UIPI. The thread of a process can post messages only to message queues of threads in processes of lesser or equal integrity level.

There is no mention of such restrictions on SendNotifyMessage(). Since you don't check the return value of either, you could be running into that, and you wouldn't know it.

Answer 3

You may need to register your message using RegisterWindowMessage() -- see the Remarks section of this MSDN article