Changeset 2084 for trunk/src/user32/win32wbase.cpp

Timestamp:

Dec 16, 1999, 1:11:49 AM (26 years ago)

Author:

sandervl

Message:

sendmessage + hook updates + misc fixes

File:

• trunk/src/user32/win32wbase.cpp (modified) (43 diffs)

trunk/src/user32/win32wbase.cpp

@@ -1 @@
-/* $Id: win32wbase.cpp,v 1.110 1999-12-14 19:13:19 sandervl Exp $ */
+/* $Id: win32wbase.cpp,v 1.111 1999-12-16 00:11:46 sandervl Exp $ */
 /*
  * Win32 Window Base Class for OS/2
@@ -11 +11 @@
  *
  * TODO: Not thread/process safe
- * TODO: Calling window handler directly from SendMessageA/W can cause problems
- *       for GetMessageTime/Pos & InSendMessage
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -28 +26 @@
 #include <winres.h>
 #include "wndmsg.h"
-#include "hooks.h"
 #include "oslibwin.h"
 #include "oslibutil.h"
@@ -44 +41 @@
 #include <wprocess.h>
 #include "winmouse.h"
+#include <win\hook.h>
 
 #define HAS_DLGFRAME(style,exStyle) \
@@ -81 +79 @@
 
 static fDestroyAll = FALSE;
+//For quick lookup of current process id
+static ULONG currentProcessId = -1;
 
 //******************************************************************************
@@ -145 +145 @@
   fNoSizeMsg       = FALSE;
   fIsDestroyed     = FALSE;
+  fDestroyWindowCalled = FALSE;
   fCreated         = FALSE;
   fTaskList        = FALSE;
@@ -203 +204 @@
 
   ownDC              = 0;
+
+  if(currentProcessId == -1)
+  {
+        currentProcessId = GetCurrentProcessId();
+  }
+  dwThreadId         = GetCurrentThreadId();
+  dwProcessId        = currentProcessId;
 }
 //******************************************************************************
@@ -461 +469 @@
   windowClass->IncreaseWindowCount();
 
+  if (HOOK_IsHooked( WH_CBT ))
+  {
+        CBT_CREATEWNDA cbtc;
+        LRESULT ret;
+
+        cbtc.lpcs = cs;
+        cbtc.hwndInsertAfter = hwndLinkAfter;
+        ret = HOOK_CallHooksA(WH_CBT, HCBT_CREATEWND, getWindowHandle(), (LPARAM)&cbtc);
+        if(ret)
+        {
+            dprintf(("CBT-hook returned 0!!"));
+            SetLastError(ERROR_CAN_NOT_COMPLETE); //todo: wrong error
+            return FALSE;
+        }
+  }
+
   /* Correct the window style */
   if (!(cs->style & WS_CHILD))
@@ -510 +534 @@
   }
 
-  if(((cs->style & 0xC0000000) == WS_OVERLAPPED) && ((cs->style & WS_CAPTION) == WS_CAPTION) && owner == NULL)
+  if(((dwStyle & 0xC0000000) == WS_OVERLAPPED) && ((dwStyle & WS_CAPTION) == WS_CAPTION) && owner == NULL
+     && dwStyle & WS_SYSMENU)
   {
-            fTaskList = TRUE;
+        fTaskList = TRUE;
   }
 
@@ -697 +722 @@
   fNoSizeMsg = FALSE;
 
-  if(SendMessageA(WM_NCCREATE, 0, (LPARAM)cs) )
+  if(SendInternalMessageA(WM_NCCREATE, 0, (LPARAM)cs) )
   {
         fCreated = TRUE;
@@ -704 +729 @@
 
 //        OffsetRect(&rectWindow, maxPos.x - rectWindow.left, maxPos.y - rectWindow.top);
-        if( (SendMessageA(WM_CREATE, 0, (LPARAM)cs )) != -1 )
+        if( (SendInternalMessageA(WM_CREATE, 0, (LPARAM)cs )) != -1 )
         {
             if(!(flags & WIN_NEED_SIZE)) {
-                SendMessageA(WM_SIZE, SIZE_RESTORED,
+                SendInternalMessageA(WM_SIZE, SIZE_RESTORED,
                                 MAKELONG(rectClient.right-rectClient.left,
                                          rectClient.bottom-rectClient.top));
-                SendMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
+                SendInternalMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
             }
 
+            if( getStyle() & WS_CHILD && !(getExStyle() & WS_EX_NOPARENTNOTIFY) )
+            {
+                /* Notify the parent window only */
+                SendInternalMessageA(WM_PARENTNOTIFY, MAKEWPARAM(WM_CREATE, getWindowId()), (LPARAM)getWindowHandle());
+                if(!::IsWindow(getWindowHandle()))
+                {
+                    dprintf(("Createwindow: WM_PARENTNOTIFY destroyed window"));
+                    goto end;
+                }
+            }
+
             if (cs->style & WS_VISIBLE) ShowWindow( sw );
 
-#if 0
             /* Call WH_SHELL hook */
-
-            if (!(dwStyle & WS_CHILD) && !owner)
-                HOOK_CallHooks16( WH_SHELL, HSHELL_WINDOWCREATED, hwnd, 0 );
-#endif
+            if (!(getStyle() & WS_CHILD) && !owner)
+                HOOK_CallHooksA(WH_SHELL, HSHELL_WINDOWCREATED, getWindowHandle(), 0 );
+
             SetLastError(0);
             return TRUE;
@@ -727 +761 @@
   dprintf(("Window creation FAILED (NCCREATE cancelled creation)"));
   SetLastError(ERROR_OUTOFMEMORY); //TODO: Better error
+end:
   return FALSE;
 }
@@ -755 +790 @@
 
     fIsDestroyed = TRUE;
-    //According to the SDK, WM_PARENTNOTIFY messages are sent to the parent (this window)
-    //before any window destruction has begun
-    child = (Win32BaseWindow *)getFirstChild();
-    while(child) {
-        child->NotifyParent(WM_DESTROY, 0, 0);
-
-        child = (Win32BaseWindow *)child->getNextChild();
+
+    if(fDestroyWindowCalled == FALSE)
+    {//this window was destroyed because DestroyWindow was called for it's parent
+     //so: send a WM_PARENTNOTIFY now as that hasn't happened yet
+        if((getStyle() & WS_CHILD) && !(getExStyle() & WS_EX_NOPARENTNOTIFY))
+        {
+            if(getParent())
+            {
+                    /* Notify the parent window only */
+                    getParent()->SendMessageA(WM_PARENTNOTIFY, MAKEWPARAM(WM_DESTROY, getWindowId()), (LPARAM)getWindowHandle());
+            }
+            else    DebugInt3();
+        }
     }
     SendInternalMessageA(WM_DESTROY, 0, 0);
+    SendInternalMessageA(WM_NCDESTROY, 0, 0);
 
     if (hwndHorzScroll && OSLibWinQueryWindow(hwndHorzScroll,QWOS_PARENT) == OSLibWinQueryObjectWindow()) OSLibWinDestroyWindow(hwndHorzScroll);
@@ -828 +870 @@
     return SendInternalMessageA(WM_MOVE, 0, MAKELONG((USHORT)x, (USHORT)y));
 }
+//******************************************************************************
+//******************************************************************************
+#if 0
+ULONG Win32BaseWindow::MsgMinMax()
+{
+
+}
+#endif
 //******************************************************************************
 //******************************************************************************
@@ -901 +951 @@
 {
  ULONG rc, curprocid, procidhwnd = -1, threadidhwnd = 0;
+
 
     //According to SDK docs, if app returns FALSE & window is being deactivated,
@@ -1151 +1202 @@
 
         /* Activate the window if needed */
-    if(isSubclassedOS2Wnd()) {
-        Win32BaseWindow *parentwnd = GetWindowFromOS2FrameHandle(OSLibWinQueryWindow(OS2Hwnd, QWOS_PARENT));
-        if(parentwnd) {
-            hwndTop = (parentwnd->GetTopParent()) ? parentwnd->GetTopParent()->getWindowHandle() : 0;
-        }
-        else    hwndTop = 0;
-    }
-    else    hwndTop = (GetTopParent()) ? GetTopParent()->getWindowHandle() : 0;
+        if(isSubclassedOS2Wnd()) {
+                Win32BaseWindow *parentwnd = GetWindowFromOS2FrameHandle(OSLibWinQueryWindow(OS2Hwnd, QWOS_PARENT));
+                if(parentwnd) {
+                        hwndTop = (parentwnd->GetTopParent()) ? parentwnd->GetTopParent()->getWindowHandle() : 0;
+                }
+                else    hwndTop = 0;
+        }
+        else    hwndTop = (GetTopParent()) ? GetTopParent()->getWindowHandle() : 0;
 
         if (hwndTop && getWindowHandle() != GetActiveWindow())
         {
-                LONG ret = SendMessageA(WM_MOUSEACTIVATE, hwndTop,
-                                        MAKELONG( HTCLIENT, win32msg ) );
+                LONG ret = SendInternalMessageA(WM_MOUSEACTIVATE, hwndTop,
+                                                MAKELONG( HTCLIENT, win32msg ) );
 
 #if 0
@@ -1447 +1498 @@
 
     case SC_CLOSE:
-        return SendMessageA(WM_CLOSE, 0, 0);
+        return SendInternalMessageA(WM_CLOSE, 0, 0);
 
 #if 0
@@ -1627 +1678 @@
         {
             if(getParent()) {
-                LRESULT rc = getParent()->SendMessageA(WM_MOUSEACTIVATE, wParam, lParam );
+                LRESULT rc = getParent()->SendInternalMessageA(WM_MOUSEACTIVATE, wParam, lParam );
                 if(rc)  return rc;
             }
@@ -1639 +1690 @@
         {
             if(getParent()) {
-                LRESULT rc = getParent()->SendMessageA(WM_SETCURSOR, wParam, lParam);
+                LRESULT rc = getParent()->SendInternalMessageA(WM_SETCURSOR, wParam, lParam);
                 if(rc)  return rc;
             }
@@ -1665 +1716 @@
 
         if (!(wpos->flags & SWP_NOMOVE) && !(wpos->flags & SWP_NOCLIENTMOVE))
-            SendMessageA(WM_MOVE, 0, MAKELONG(rectClient.left, rectClient.top));
+            SendInternalMessageA(WM_MOVE, 0, MAKELONG(rectClient.left, rectClient.top));
 
         if (!(wpos->flags & SWP_NOSIZE) && !(wpos->flags & SWP_NOCLIENTSIZE))
@@ -1672 +1723 @@
             else if (dwStyle & WS_MINIMIZE) wp = SIZE_MINIMIZED;
 
-            SendMessageA(WM_SIZE, wp, MAKELONG(rectClient.right  - rectClient.left,
+            SendInternalMessageA(WM_SIZE, wp, MAKELONG(rectClient.right  - rectClient.left,
                                                rectClient.bottom - rectClient.top));
         }
@@ -1779 +1830 @@
           // key matches siblings mnemonic, send mouseclick
           if (mnemonic == (char) wParam) {
-            siblingWindow->SendMessageA (BM_CLICK, 0, 0);
+            siblingWindow->SendInternalMessageA (BM_CLICK, 0, 0);
           }
 
@@ -1873 +1924 @@
 LRESULT Win32BaseWindow::SendMessageA(ULONG Msg, WPARAM wParam, LPARAM lParam)
 {
+ POSTMSG_PACKET *packet;
+
+    //if the destination window is created by this process & thread, call window proc directly
+    if(dwProcessId == currentProcessId && dwThreadId == GetCurrentThreadId()) {
+        return SendInternalMessageA(Msg, wParam, lParam);
+    }
+    //otherwise use WinSendMsg to send it to the right process/thread
+    packet = (POSTMSG_PACKET *)_smalloc(sizeof(POSTMSG_PACKET));
+    packet->Msg = Msg;
+    packet->wParam = wParam;
+    packet->lParam = lParam;
+    packet->fUnicode = FALSE;
+    return OSLibSendMessage(getOS2WindowHandle(), WIN32APP_POSTMSG, WIN32PM_MAGIC, (DWORD)packet);
+}
+//******************************************************************************
+//******************************************************************************
+LRESULT Win32BaseWindow::SendMessageW(ULONG Msg, WPARAM wParam, LPARAM lParam)
+{
+ POSTMSG_PACKET *packet;
+
+    //if the destination window is created by this process & thread, call window proc directly
+    if(dwProcessId == currentProcessId && dwThreadId == GetCurrentThreadId()) {
+        return SendInternalMessageA(Msg, wParam, lParam);
+    }
+    //otherwise use WinSendMsg to send it to the right process/thread
+    packet = (POSTMSG_PACKET *)_smalloc(sizeof(POSTMSG_PACKET));
+    packet->Msg = Msg;
+    packet->wParam = wParam;
+    packet->lParam = lParam;
+    packet->fUnicode = TRUE;
+    return OSLibSendMessage(getOS2WindowHandle(), WIN32APP_POSTMSG, WIN32PM_MAGIC, (DWORD)packet);
+}
+//******************************************************************************
+//Called as a result of an OS/2 message or called from a class method
+//******************************************************************************
+LRESULT Win32BaseWindow::SendInternalMessageA(ULONG Msg, WPARAM wParam, LPARAM lParam)
+{
  LRESULT rc;
  BOOL    fInternalMsgBackup = fInternalMsg;
 
-  //SvL: Some Wine controls send WM_COMMAND messages when they receive the focus -> apps don't like to
-  //     receive those before they get their WM_CREATE message
-  //NOTE: May need to refuse more messages
-  if(fCreated == FALSE && Msg == WM_COMMAND) {
-        dprintf(("SendMessageA BEFORE creation! %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
-        return 0;
-  }
-
-  DebugPrintMessage(getWindowHandle(), Msg, wParam, lParam, FALSE, FALSE);
-
-  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
-        return(0);
-  }
-  fInternalMsg = FALSE;
+  DebugPrintMessage(getWindowHandle(), Msg, wParam, lParam, FALSE, TRUE);
+
+  CallWindowHookProc(WH_CALLWNDPROC, Msg, wParam, lParam, FALSE);
+
+  fInternalMsg = TRUE;
   switch(Msg)
   {
@@ -1899 +1978 @@
                         break;
                 }
-                NotifyParent(Msg, wParam, lParam);
-
                 rc = 0;
                 break;
         }
-        case WM_SETTEXT:
-                rc = CallWindowProcA(win32wndproc, getWindowHandle(), WM_SETTEXT, wParam, lParam);
-                break;
-
         case WM_LBUTTONDOWN:
         case WM_MBUTTONDOWN:
@@ -1916 +1989 @@
 
         case WM_DESTROY:
-                win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
                 rc = win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
                 break;
@@ -1928 +2000 @@
 }
 //******************************************************************************
-//******************************************************************************
-LRESULT Win32BaseWindow::SendMessageW(ULONG Msg, WPARAM wParam, LPARAM lParam)
+//Called as a result of an OS/2 message or called from a class method
+//******************************************************************************
+LRESULT Win32BaseWindow::SendInternalMessageW(ULONG Msg, WPARAM wParam, LPARAM lParam)
 {
  LRESULT rc;
  BOOL    fInternalMsgBackup = fInternalMsg;
 
-  //SvL: Some Wine controls send WM_COMMAND messages when they receive the focus -> apps don't like to
-  //     receive those before they get their WM_CREATE message
-  //NOTE: May need to refuse more messages
-  if(fCreated == FALSE && Msg == WM_COMMAND) {
-        dprintf(("SendMessageA BEFORE creation! %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
-        return 0;
-  }
-
-  DebugPrintMessage(getWindowHandle(), Msg, wParam, lParam, TRUE, FALSE);
-
-  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
-        return(0);
-  }
-  fInternalMsg = FALSE;
+  DebugPrintMessage(getWindowHandle(), Msg, wParam, lParam, TRUE, TRUE);
+
+  CallWindowHookProc(WH_CALLWNDPROC, Msg, wParam, lParam, TRUE);
+
+  fInternalMsg = TRUE;
   switch(Msg)
   {
@@ -1957 +2021 @@
                         break;
                 }
-                NotifyParent(Msg, wParam, lParam);
-
                 rc = 0;
                 break;
         }
-        case WM_SETTEXT:
-                rc = CallWindowProcW(win32wndproc, getWindowHandle(), WM_SETTEXT, wParam, lParam);
-                break;
-
         case WM_LBUTTONDOWN:
         case WM_MBUTTONDOWN:
@@ -1974 +2032 @@
 
         case WM_DESTROY:
-                win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
-                rc = win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
-                break;
-
-        default:
-                rc = CallWindowProcW(win32wndproc, getWindowHandle(), Msg, wParam, lParam);
-                break;
-  }
-  fInternalMsg = fInternalMsgBackup;
-  return rc;
-}
-//******************************************************************************
-//Called as a result of an OS/2 message
-//******************************************************************************
-LRESULT Win32BaseWindow::SendInternalMessageA(ULONG Msg, WPARAM wParam, LPARAM lParam)
-{
- LRESULT rc;
- BOOL    fInternalMsgBackup = fInternalMsg;
-
-  DebugPrintMessage(getWindowHandle(), Msg, wParam, lParam, FALSE, TRUE);
-
-  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
-        return(0);
-  }
-  fInternalMsg = TRUE;
-  switch(Msg)
-  {
-        case WM_CREATE:
-        {
-                if(CallWindowProcA(win32wndproc, getWindowHandle(), WM_CREATE, 0, lParam) == -1) {
-                        dprintf(("WM_CREATE returned -1\n"));
-                        rc = -1; //don't create window
-                        break;
-                }
-                NotifyParent(Msg, wParam, lParam);
-                rc = 0;
-                break;
-        }
-        case WM_LBUTTONDOWN:
-        case WM_MBUTTONDOWN:
-        case WM_RBUTTONDOWN:
-                NotifyParent(Msg, wParam, lParam);
-                rc = win32wndproc(getWindowHandle(), Msg, wParam, lParam);
-                break;
-
-        case WM_DESTROY:
-                win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
-                rc = win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
-                break;
-
-        default:
-                rc = CallWindowProcA(win32wndproc, getWindowHandle(), Msg, wParam, lParam);
-                break;
-  }
-  fInternalMsg = fInternalMsgBackup;
-  return rc;
-}
-//******************************************************************************
-//Called as a result of an OS/2 message
-//todo, unicode msgs (WM_SETTEXT etc)
-//******************************************************************************
-LRESULT Win32BaseWindow::SendInternalMessageW(ULONG Msg, WPARAM wParam, LPARAM lParam)
-{
- LRESULT rc;
- BOOL    fInternalMsgBackup = fInternalMsg;
-
-  DebugPrintMessage(getWindowHandle(), Msg, wParam, lParam, TRUE, TRUE);
-
-  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
-        return(0);
-  }
-  fInternalMsg = TRUE;
-  switch(Msg)
-  {
-        case WM_CREATE:
-        {
-                if(CallWindowProcW(win32wndproc, getWindowHandle(), WM_CREATE, 0, lParam) == -1) {
-                        dprintf(("WM_CREATE returned -1\n"));
-                        rc = -1; //don't create window
-                        break;
-                }
-                NotifyParent(Msg, wParam, lParam);
-                rc = 0;
-                break;
-        }
-        case WM_LBUTTONDOWN:
-        case WM_MBUTTONDOWN:
-        case WM_RBUTTONDOWN:
-                NotifyParent(Msg, wParam, lParam);
-                rc = win32wndproc(getWindowHandle(), Msg, wParam, lParam);
-                break;
-
-        case WM_DESTROY:
-                win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
                 rc = win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
                 break;
@@ -2079 +2043 @@
 //******************************************************************************
 //******************************************************************************
+void Win32BaseWindow::CallWindowHookProc(ULONG hooktype, ULONG Msg, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
+{
+ CWPSTRUCT cwp;
+
+    cwp.lParam  = lParam;
+    cwp.wParam  = wParam;
+    cwp.message = Msg;
+    cwp.hwnd    = getWindowHandle();
+
+    switch(hooktype) {
+    case WH_CALLWNDPROC:
+        if(fUnicode) {
+             HOOK_CallHooksW(WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp);
+        }
+        else HOOK_CallHooksA(WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp);
+        break;
+    }
+}
+//******************************************************************************
+//******************************************************************************
 BOOL Win32BaseWindow::PostMessageA(ULONG msg, WPARAM wParam, LPARAM lParam)
 {
@@ -2127 +2111 @@
 //******************************************************************************
 //******************************************************************************
-void Win32BaseWindow::PostMessage(POSTMSG_PACKET *packet)
-{
+ULONG Win32BaseWindow::PostMessage(POSTMSG_PACKET *packet)
+{
+ ULONG rc;
+
     if(packet == NULL)
-        return;
+        return 0;
 
     if(packet->fUnicode) {
-            SendMessageW(packet->Msg, packet->wParam, packet->lParam);
-    }
-    else    SendMessageA(packet->Msg, packet->wParam, packet->lParam);
+            rc = SendInternalMessageW(packet->Msg, packet->wParam, packet->lParam);
+    }
+    else    rc = SendInternalMessageA(packet->Msg, packet->wParam, packet->lParam);
 
     free(packet);
-}
-//******************************************************************************
-//Send message to window of another process
-//******************************************************************************
-LRESULT Win32BaseWindow::SendMessageToProcess(UINT msg, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
-{
- POSTMSG_PACKET *packet = (POSTMSG_PACKET *)_smalloc(sizeof(POSTMSG_PACKET));
-
-    dprintf(("SendMessageToProcess %x %x %x %x", getOS2WindowHandle(), msg, wParam, lParam));
-    packet->Msg = msg;
-    packet->wParam = wParam;
-    packet->lParam = lParam;
-    packet->fUnicode = fUnicode;
-    return OSLibSendMessage(getOS2WindowHandle(), WIN32APP_POSTMSG, WIN32PM_MAGIC, (DWORD)packet);
+    return rc;
 }
 //******************************************************************************
@@ -2160 +2133 @@
  Win32BaseWindow *window;
  HWND hwnd = WNDHANDLE_MAGIC_HIGHWORD;
- DWORD processid, myprocessid;
 
     dprintf(("BroadCastMessageA %x %x %x", msg, wParam, lParam, GetFS()));
-    myprocessid = GetCurrentProcessId();
 
     for(int i=0;i<MAX_WINDOW_HANDLES;i++) {
@@ -2172 +2143 @@
 
                 if(type == BROADCAST_SEND) {
-                        GetWindowThreadProcessId(hwnd, &processid);
-                        if(processid == myprocessid) {
-                            window->SendMessageA(msg, wParam, lParam);
-                        }
-                        else {
-                            window->SendMessageToProcess(msg, wParam, lParam, FALSE);
-                        }
+                        window->SendInternalMessageA(msg, wParam, lParam);
                 }
                 else    window->PostMessageA(msg, wParam, lParam);
@@ -2193 +2158 @@
  Win32BaseWindow *window;
  HWND hwnd = WNDHANDLE_MAGIC_HIGHWORD;
- DWORD processid, myprocessid;
 
 
     dprintf(("BroadCastMessageW %x %x %x", msg, wParam, lParam));
-    myprocessid = GetCurrentProcessId();
 
     for(int i=0;i<MAX_WINDOW_HANDLES;i++) {
@@ -2206 +2169 @@
 
                 if(type == BROADCAST_SEND) {
-                        GetWindowThreadProcessId(hwnd, &processid);
-                        if(processid == myprocessid) {
-                            window->SendMessageW(msg, wParam, lParam);
-                        }
-                        else {
-                            window->SendMessageToProcess(msg, wParam, lParam, TRUE);
-                        }
+                        window->SendInternalMessageW(msg, wParam, lParam);
                 }
                 else    window->PostMessageW(msg, wParam, lParam);
@@ -2221 +2178 @@
 }
 //******************************************************************************
-//TODO: do we need to inform the parent of the parent (etc) of the child window?
 //******************************************************************************
 void Win32BaseWindow::NotifyParent(UINT Msg, WPARAM wParam, LPARAM lParam)
@@ -2235 +2191 @@
                 parentwindow = window->getParent();
                 if(parentwindow) {
-                        if(Msg == WM_CREATE || Msg == WM_DESTROY) {
-                                parentwindow->SendMessageA(WM_PARENTNOTIFY, MAKEWPARAM(Msg, getWindowId()), (LPARAM)getWindowHandle());
-                        }
-                        else    parentwindow->SendMessageA(WM_PARENTNOTIFY, MAKEWPARAM(Msg, getWindowId()), lParam );
+                        parentwindow->SendInternalMessageA(WM_PARENTNOTIFY, MAKEWPARAM(Msg, getWindowId()), lParam );
                 }
         }
@@ -2283 +2236 @@
     if(OSLibWinSetIcon(OS2HwndFrame, hIcon) == TRUE) {
 //TODO: Wine does't send these. Correct?
-//        SendMessageA(WM_SETICON, ICON_BIG, hIcon);
+//        SendInternalMessageA(WM_SETICON, ICON_BIG, hIcon);
         return TRUE;
     }
@@ -2309 +2262 @@
             wParam = SIZE_MINIMIZED;
 
-        SendMessageA(WM_SIZE, wParam,
+        SendInternalMessageA(WM_SIZE, wParam,
                      MAKELONG(rectClient.right-rectClient.left,
                               rectClient.bottom-rectClient.top));
-        SendMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
+        SendInternalMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
     }
 #else
     if(fFirstShow) {
         if(isFrameWindow() && IS_OVERLAPPED(getStyle()) && !isChild()) {
-                SendMessageA(WM_SIZE, SIZE_RESTORED,
+                SendInternalMessageA(WM_SIZE, SIZE_RESTORED,
                                 MAKELONG(rectClient.right-rectClient.left,
                                          rectClient.bottom-rectClient.top));
-                SendMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
+                SendInternalMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
 
         }
@@ -2491 +2444 @@
 }
 //******************************************************************************
-//Also destroys all the child windows (destroy parent, destroy children)
+//Also destroys all the child windows (destroy children first, parent last)
 //******************************************************************************
 BOOL Win32BaseWindow::DestroyWindow()
 {
+    /* Call hooks */
+    if(HOOK_CallHooksA( WH_CBT, HCBT_DESTROYWND, getWindowHandle(), 0L))
+    {
+        return FALSE;
+    }
+
+    if(!(getStyle() & WS_CHILD) && getOwner() == NULL)
+    {
+        HOOK_CallHooksA(WH_SHELL, HSHELL_WINDOWDESTROYED, getWindowHandle(), 0L);
+        /* FIXME: clean up palette - see "Internals" p.352 */
+    }
+
+    if((getStyle() & WS_CHILD) && !(getExStyle() & WS_EX_NOPARENTNOTIFY))
+    {
+        if(getParent())
+        {
+             /* Notify the parent window only */
+             getParent()->SendMessageA(WM_PARENTNOTIFY, MAKEWPARAM(WM_DESTROY, getWindowId()), (LPARAM)getWindowHandle());
+             if( !::IsWindow(getWindowHandle()) )
+             {
+                return TRUE;
+             }
+        }
+        else DebugInt3();
+    }
+    fDestroyWindowCalled = TRUE;
     return OSLibWinDestroyWindow(OS2HwndFrame);
 }
@@ -2590 +2569 @@
         if (isIcon)
         {
-            SendMessageA(WM_ICONERASEBKGND, (WPARAM)hdc, 0);
-            SendMessageA(WM_PAINTICON, 0, 0);
-        } else
-        {
-            SendMessageA(WM_ERASEBKGND, (WPARAM)hdc, 0);
-            SendMessageA(WM_PAINT, 0, 0);
+            SendInternalMessageA(WM_ICONERASEBKGND, (WPARAM)hdc, 0);
+            SendInternalMessageA(WM_PAINTICON, 0, 0);
+        }
+        else
+        {
+            SendInternalMessageA(WM_ERASEBKGND, (WPARAM)hdc, 0);
+            SendInternalMessageA(WM_PAINT, 0, 0);
         }
         O32_ReleaseDC(OS2Hwnd, hdc);
@@ -2999 +2979 @@
                 ss.styleNew = value;
                 dprintf(("SetWindowLong GWL_EXSTYLE %x old %x new style %x", getWindowHandle(), dwExStyle, value));
-                SendMessageA(WM_STYLECHANGING,GWL_EXSTYLE,(LPARAM)&ss);
+                SendInternalMessageA(WM_STYLECHANGING,GWL_EXSTYLE,(LPARAM)&ss);
                 setExStyle(ss.styleNew);
                 updateWindowStyle(ss.styleOld,getStyle());
-                SendMessageA(WM_STYLECHANGED,GWL_EXSTYLE,(LPARAM)&ss);
+                SendInternalMessageA(WM_STYLECHANGED,GWL_EXSTYLE,(LPARAM)&ss);
                 return ss.styleOld;
         }
@@ -3016 +2996 @@
                         ss.styleNew = value | (ss.styleOld & (WS_VISIBLE | WS_CHILD));
                 dprintf(("SetWindowLong GWL_STYLE %x old %x new style %x", getWindowHandle(), getStyle(), value));
-                SendMessageA(WM_STYLECHANGING,GWL_STYLE,(LPARAM)&ss);
+                SendInternalMessageA(WM_STYLECHANGING,GWL_STYLE,(LPARAM)&ss);
                 setStyle(ss.styleNew);
                 updateWindowStyle(dwExStyle,ss.styleOld);
-                SendMessageA(WM_STYLECHANGED,GWL_STYLE,(LPARAM)&ss);
+                SendInternalMessageA(WM_STYLECHANGED,GWL_STYLE,(LPARAM)&ss);
 #ifdef DEBUG
                 PrintWindowStyle(ss.styleNew, 0);
@@ -3027 +3007 @@
         case GWL_WNDPROC:
                 oldval = (LONG)WINPROC_GetProc(win32wndproc, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A);
-                WINPROC_SetProc((HWINDOWPROC *)&win32wndproc, (WNDPROC)value, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A, WIN_PROC_WINDOW);
+                //WINPROC_SetProc((HWINDOWPROC *)&win32wndproc, (WNDPROC)value, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A, WIN_PROC_WINDOW);
+                WINPROC_SetProc((HWINDOWPROC *)&win32wndproc, (WNDPROC)value, WINPROC_GetProcType(win32wndproc), WIN_PROC_WINDOW);
                 return oldval;
         case GWL_HINSTANCE: