DM>Почему когда я из одного потока посылаю в др. WM_QUIT при помощи SendMessage, то GetMessage не возвращает 0, а когда использую PostMessage, то все нормально??? В чем разница? Самое интерестное, что Spy++ пишет что сообщение послано — принято. Помогите плиз.

The WM_QUIT message is not associated with a window and therefore will never be received through a window's window procedure. It is retrieved only by the GetMessage or PeekMessage functions.

Do not post the WM_QUIT message using the PostMessage function; use PostQuitMessage.

LRESULT 
DispatchMessage
  ( CONST MSG *lpmsg )
{
// ***********************
//  Обработка каллбека таймера, если обрабатываем сообщение WM_TIMER, если такой имееться
// ***********************
//  Возможно что то еще: проверки на валидность оконного хендла, етс.
// ***********************

  return SendMessage
    ( lpmsg->hwnd,
    , lpmsg->message
    , lpmsg->wParam
    , lpmsg->lParam );
}

LRESULT SendMessage
  ( HWND hWnd
  , UINT Msg
  , WPARAM wParam
  , LPARAM lParam)
{
// ***********************
//  Что то тут есть: проверка на валидность оконного хендла, синхранизация многопоточности етс.
// ***********************

  return CallWindowProc
    ( (WNDPROC) GetWindowLong (lpmsg->hwnd, GWL_WNDPROC)
    , lpmsg->message
    , lpmsg->wParam
    , lpmsg->lParam );
}

while(GetMessage(...) {...}

PostQuitMessage(0);
PostMessage(hwnd,msg,wparam,lparam);

A>Извини — наверное где то неправильно выразился

A>LRESULT 
A>DispatchMessage
A>  ( CONST MSG *lpmsg )
A>{
A>// ***********************
A>//  Обработка каллбека таймера, если обрабатываем сообщение WM_TIMER, если такой имееться
A>// ***********************
A>//  Возможно что то еще: проверки на валидность оконного хендла, етс.
A>// ***********************

A>  return SendMessage
A>    ( lpmsg->hwnd,
A>    , lpmsg->message
A>    , lpmsg->wParam
A>    , lpmsg->lParam );
A>}
A>

A>LRESULT SendMessage
A>  ( HWND hWnd
A>  , UINT Msg
A>  , WPARAM wParam
A>  , LPARAM lParam)
A>{
A>// ***********************
A>//  Что то тут есть: проверка на валидность оконного хендла, синхранизация многопоточности етс.
A>// ***********************

A>  return CallWindowProc
A>    ( (WNDPROC) GetWindowLong (lpmsg->hwnd, GWL_WNDPROC)
A>    , lpmsg->message
A>    , lpmsg->wParam
A>    , lpmsg->lParam );
A>}
A>

A>з.ы. кстати — сейчас попробую, и напишу

LRESULT SendMessage(HWND hWnd, UINT Msg , WPARAM wParam , LPARAM lParam)
{
   DWORD dwThreadID = System::GetWindowNativeThreadID(hWnd);
   System::MessageQueue* pQueue = System::GetThreadMessageQueue(dwThreadID);
   MSG msg(Msg, wParam, lParam)
   return pQueue->AddSync(&msg);
}

LRESULT System::MessageQueue::AddSync(MSG* pMsg)
{
   SyncMSGWrapper SyncMsg(pMsg);
   m_mtx.Lock();
   m_list.push_back(&SyncMsg)
   m_mtx.Unlock();
   m_NewMsgEvent.Set();
   if(WaitForXXXX(SyncMsg.m_ProcessedEvent.GetHandle(), INFINITE) == WAIT_OBJECT_0)
      return SyncMsg.GetResult();
   else
      обработка ошибок
}

BOOL GetMessage(MSG* pMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax)
{
   System::MessageQueue* pQueue = System::GetThreadMessageQueue(::GetCurrentThreadID());
   return pQueue->GetMessage(pMsg, hWnd, wMsgFilterMin,wMsgFilterMax);
}

BOOL System::MessageQueue::GetMessage(MSG* pMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax)
{
   if(::GetCurrentThreadID() != m_dwNativeThreadID)
       return -1;
   while(TRUE)
   {
    m_mtx.Lock();
    if(m_list.empty())
    {
        if(WaitForXXX(m_NewMsgEvent.GetHandle(), INFINiTE) == WAIT_OBJECT_0)
            break;
    }
    else
    {
      for(iter i = m_list.begin(); i != m_list.end(); ++i)
      {
          SystemMSG* pMSG = *i;
          if(pMSG->IsSync())
          {
             FindAndCallWindowProc(pMSG);
             pMsg->m_ProcessedEvent.Set();
             m_list.erase(i);
          }
      }
      // далее поиск на соотв фильтру асинхронного сообщения и возврат
      // первого подходящего
       
    }
  }
}

KL> НЕВЕРНО!!! Если поток не вызывает GetMessage или PeekMessage сообщение НИКОГДА не будет обработанно!

LRESULT SendMessage(HWND hWnd, UINT Msg , WPARAM wParam , LPARAM lParam)
{
   DWORD dwThreadID = System::GetWindowNativeThreadID(hWnd);
   System::MessageQueue* pQueue = System::GetThreadMessageQueue(dwThreadID);
   if(GetCurrentThreadId() == pQueue->GetNativeThredId())
      вызывается оконная процедура
   else
   {
     MSG msg(Msg, wParam, lParam)
     return pQueue->AddSync(&msg);
   }
}
далее смотри мой предыдущий пост...

AS>Вот те здрасте! GetMessage вызывает напрямую оконную процедуру? Это ты где такое вычитал? Хе-хе.

case WM_USER + 0x100: MessageBepp (0); break;

for ( ; ; );

while (Get(Peek)Message (...));

A>А ты проверь, как я .

A>case WM_USER + 0x100: MessageBepp (0); break;
A>

A>а потом зациклись в пустоте

A>for ( ; ; ); 
A>

A>Оно никогда не дойдет . И окно твое "висеть" будет. В прямом смысле слова.

A>while (Get(Peek)Message (...)); 
A>

while (Get(Peek)Message (...));

Sleep(INFINITE);

A>GetMessage — выгребает с возвращением только PostMessage. Kirill и Павел правы.

while (GetMessage(&msg, NULL, 0, 0));

KL>А если все равно не веришь — попробуй из GetMessage получить хотя бы одно

KL>синхронное сообщение, успехов...

GetWindowLong(hwnd, GWL_WINDOWPROC);

BOOL GetClassInfo( 
HINSTANCE hInstance, 
LPCTSTR lpClassName, 
LPWNDCLASS lpWndClass); 

int GetClassName(
  HWND hWnd,           
  LPTSTR lpClassName,  
  int nMaxCount        
);

while (GetMessage(&msg, NULL, 0, 0));

DWORD* GetWndPointer(HWND hwnd) // hwnd is the handle of any window in the system
{
    DWORD user32_si; //user32 shared info; gSharedInfo
    DWORD pWND;
    DWORD local_correction;
    
    // 0x58180 is the offset of gSharedInfo in "user32.dll"
    user32_si=(DWORD)GetModuleHandle("user32.dll")+0x58180;

    pWND=*(DWORD*)(user32_si+4);
    pWND+=LOWORD(hwnd)*12;
    pWND=*(DWORD*)pWND; // now pWND points to the real WND structure above 2 GB
    // and this is a writable memory if we were running in system mode (ring 0)
    // but in user mode (ring 3) we could't even read it
    // this is something like 0xA03xxxxx this is where I want to
    // write 
    /*
    local_correction=*((DWORD *)0x7ffde6e8);
    // [7ffde6e8] - the value that must be subtracted from the pointer above 2 GB
    // in order to get user-mode accessible pointer to the window structure 
    pWND-=local_correction;
    // the new pointer points to read only memory but it is mapped to the same physical address as the
    // pointer above 2 GB, that is before the correction is made
    */
    return (DWORD*)pWND;
}