Changeset 2084 for trunk/src

Timestamp:

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

Author:

sandervl

Message:

sendmessage + hook updates + misc fixes

Location:

trunk/src/user32

Files:

• HOOK.CPP (modified) (1 diff)
• Makefile (modified) (4 diffs)
• hooks.cpp (deleted)
• hooks.h (deleted)
• pmwindow.cpp (modified) (3 diffs)
• user32.cpp (modified) (2 diffs)
• win32dlg.cpp (modified) (8 diffs)
• win32wbase.cpp (modified) (43 diffs)
• win32wbase.h (modified) (5 diffs)
• win32wbasepos.cpp (modified) (5 diffs)
• win32wmdichild.cpp (modified) (4 diffs)
• win32wmdiclient.cpp (modified) (12 diffs)
• win32wnd.cpp (modified) (2 diffs)
• window.cpp (modified) (4 diffs)
• windowmsg.cpp (modified) (2 diffs)
• winmenu.cpp (modified) (2 diffs)

trunk/src/user32/HOOK.CPP

@@ -1 @@
-/* $Id: HOOK.CPP,v 1.5 1999-09-15 23:18:47 sandervl Exp $ */
+/* $Id: HOOK.CPP,v 1.6 1999-12-16 00:11:44 sandervl Exp $ */
 
 /*
- * Win32 hook API functions for OS/2
- *
- * Copyright 1998 Sander van Leeuwen
+ * Windows hook functions
+ *
+ * Copyright 1999 Sander van Leeuwen (OS/2 Port)
+ *
+ * Port of Wine code (windows\hook.c; dated 990920)
+ * All 16 bits code removed
+ *
+ * Copyright 1994, 1995 Alexandre Julliard
+ *                 1996 Andrew Lewycky
+ *
+ * Based on investigations by Alex Korobka
  *
  *
  * Project Odin Software License can be found in LICENSE.TXT
- *
- */
+ */
+
+/*
+ * Warning!
+ * A HHOOK is a 32-bit handle for compatibility with Windows 3.0 where it was
+ * a pointer to the next function. Now it is in fact composed of a USER heap
+ * handle in the low 16 bits and of a HOOK_MAGIC value in the high 16 bits.
+ */
+
 #include <os2win.h>
-#include <stdarg.h>
-#include "misc.h"
-#include "hooks.h"
-
-//******************************************************************************
-//******************************************************************************
-HHOOK WIN32API SetWindowsHookExA(int idHook, HOOKPROC hkprc, HINSTANCE hmod, DWORD dwThreadId)
-{
- HHOOK    rc;
- HOOKPROC_O32 os2hkprc;
-
-    switch(idHook) {
-        case WH_CALLWNDPROC:
-                os2hkprc = HkWindow::GetOS2Hook();
-                break;
-        case WH_CBT:
+#include "hook.h"
+#include "win.h"
+#include "queue.h"
+#include "task.h"
+#include "winproc.h"
+#include "debugtools.h"
+#include <misc.h>
+#include <heapstring.h>
+#include <vmutex.h>
+#include <wprocess.h>
+
+DEFAULT_DEBUG_CHANNEL(hook)
+
+#include "pshpack1.h"
+
+  /* Hook data (pointed to by a HHOOK) */
+typedef struct
+{
+    HANDLE     next;               /* 00 Next hook in chain */
+    HOOKPROC   proc;               /* 04 Hook procedure (original) */
+    INT        id;                 /* 08 Hook id (WH_xxx) */
+    DWORD      ownerThread;        /* 0C Owner thread (0 for system hook) */
+    HMODULE    ownerModule;        /* 10 Owner module */
+    DWORD      flags;              /* 14 flags */
+    DWORD      magic;              /* 18 magic dword */
+} HOOKDATA;
+
+#include "poppack.h"
+
+#define HOOK_MAGIC1  ((int)'H' | (int)'K' << 8)  /* 'HK' */
+#define HOOK_MAGIC ((HOOK_MAGIC1<<16)|HOOK_MAGIC1) // 'HKHK'
+
+#define CHECK_MAGIC(a) ((a != 0) && (((HOOKDATA *)a)->magic == HOOK_MAGIC))
+
+//Global DLL Data
+#pragma data_seg(_GLOBALDATA)
+static HANDLE HOOK_systemHooks[WH_NB_HOOKS] = { 0 };
+static VMutex systemHookMutex(TRUE);
+#pragma data_seg()
+static HANDLE HOOK_threadHooks[WH_NB_HOOKS] = { 0 };
+static VMutex threadHookMutex;
+
+typedef VOID (*HOOK_MapFunc)(INT, INT, WPARAM *, LPARAM *);
+typedef VOID (*HOOK_UnMapFunc)(INT, INT, WPARAM, LPARAM, WPARAM,
+                               LPARAM);
+
+/***********************************************************************
+ *           HOOK_Map32ATo32W
+ */
+static void HOOK_Map32ATo32W(INT id, INT code, WPARAM *pwParam,
+                             LPARAM *plParam)
+{
+    if (id == WH_CBT && code == HCBT_CREATEWND)
+    {
+        LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)*plParam;
+        LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)HeapAlloc(GetProcessHeap(), 0,
+                                                                sizeof(*lpcbtcwW) );
+        lpcbtcwW->lpcs = (CREATESTRUCTW*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwW->lpcs) );
+
+        lpcbtcwW->hwndInsertAfter = lpcbtcwA->hwndInsertAfter;
+        *lpcbtcwW->lpcs = *(LPCREATESTRUCTW)lpcbtcwA->lpcs;
+
+        if (HIWORD(lpcbtcwA->lpcs->lpszName))
         {
-                HkCBT *hkhook = new HkCBT(0, hkprc, hmod, dwThreadId);; 
-#ifdef DEBUG
-                WriteLog("OS2SetWindowsHookExA WH_CBT %X, %X, %X, %X\n", idHook, hkprc, hmod, dwThreadId);
+            lpcbtcwW->lpcs->lpszName = HEAP_strdupAtoW( GetProcessHeap(), 0,
+                                                    lpcbtcwA->lpcs->lpszName );
+        }
+        else
+          lpcbtcwW->lpcs->lpszName = (LPWSTR)lpcbtcwA->lpcs->lpszName;
+
+        if (HIWORD(lpcbtcwA->lpcs->lpszClass))
+        {
+            lpcbtcwW->lpcs->lpszClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
+                                                   lpcbtcwA->lpcs->lpszClass );
+        }
+        else
+          lpcbtcwW->lpcs->lpszClass = (LPCWSTR)lpcbtcwA->lpcs->lpszClass;
+        *plParam = (LPARAM)lpcbtcwW;
+    }
+    return;
+}
+
+
+/***********************************************************************
+ *           HOOK_UnMap32ATo32W
+ */
+static void HOOK_UnMap32ATo32W(INT id, INT code, WPARAM wParamOrig,
+                               LPARAM lParamOrig, WPARAM wParam,
+                               LPARAM lParam)
+{
+    if (id == WH_CBT && code == HCBT_CREATEWND)
+    {
+        LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)lParam;
+        if (HIWORD(lpcbtcwW->lpcs->lpszName))
+            HeapFree( GetProcessHeap(), 0, (LPWSTR)lpcbtcwW->lpcs->lpszName );
+        if (HIWORD(lpcbtcwW->lpcs->lpszClass))
+            HeapFree( GetProcessHeap(), 0, (LPWSTR)lpcbtcwW->lpcs->lpszClass );
+        HeapFree( GetProcessHeap(), 0, lpcbtcwW->lpcs );
+        HeapFree( GetProcessHeap(), 0, lpcbtcwW );
+    }
+    return;
+}
+
+
+/***********************************************************************
+ *           HOOK_Map32WTo32A
+ */
+static void HOOK_Map32WTo32A(INT id, INT code, WPARAM *pwParam,
+                             LPARAM *plParam)
+{
+    if (id == WH_CBT && code == HCBT_CREATEWND)
+    {
+        LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)*plParam;
+        LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)HeapAlloc(GetProcessHeap(), 0,
+                                                                sizeof(*lpcbtcwA) );
+        lpcbtcwA->lpcs = (CREATESTRUCTA*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwA->lpcs) );
+
+        lpcbtcwA->hwndInsertAfter = lpcbtcwW->hwndInsertAfter;
+        *lpcbtcwA->lpcs = *(LPCREATESTRUCTA)lpcbtcwW->lpcs;
+
+        if (HIWORD(lpcbtcwW->lpcs->lpszName))
+          lpcbtcwA->lpcs->lpszName = HEAP_strdupWtoA( GetProcessHeap(), 0,
+                                                    lpcbtcwW->lpcs->lpszName );
+        else
+          lpcbtcwA->lpcs->lpszName = (LPSTR)lpcbtcwW->lpcs->lpszName;
+
+        if (HIWORD(lpcbtcwW->lpcs->lpszClass))
+          lpcbtcwA->lpcs->lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
+                                                   lpcbtcwW->lpcs->lpszClass );
+        else
+          lpcbtcwA->lpcs->lpszClass = (LPSTR)lpcbtcwW->lpcs->lpszClass;
+        *plParam = (LPARAM)lpcbtcwA;
+    }
+    return;
+}
+
+
+/***********************************************************************
+ *           HOOK_UnMap32WTo32A
+ */
+static void HOOK_UnMap32WTo32A(INT id, INT code, WPARAM wParamOrig,
+                               LPARAM lParamOrig, WPARAM wParam,
+                               LPARAM lParam)
+{
+    if (id == WH_CBT && code == HCBT_CREATEWND)
+    {
+        LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)lParam;
+        if (HIWORD(lpcbtcwA->lpcs->lpszName))
+            HeapFree( GetProcessHeap(), 0, (LPSTR)lpcbtcwA->lpcs->lpszName );
+        if (HIWORD(lpcbtcwA->lpcs->lpszClass))
+            HeapFree( GetProcessHeap(), 0, (LPSTR)lpcbtcwA->lpcs->lpszClass );
+        HeapFree( GetProcessHeap(), 0, lpcbtcwA->lpcs );
+        HeapFree( GetProcessHeap(), 0, lpcbtcwA );
+    }
+    return;
+}
+
+
+/***********************************************************************
+ *           Map Function Tables
+ */
+static const HOOK_MapFunc HOOK_MapFuncs[3][3] = 
+{
+    { NULL, NULL,             NULL },
+    { NULL, NULL,             HOOK_Map32ATo32W },
+    { NULL, HOOK_Map32WTo32A, NULL }
+};
+
+static const HOOK_UnMapFunc HOOK_UnMapFuncs[3][3] = 
+{
+    { NULL, NULL,               NULL },
+    { NULL, NULL,               HOOK_UnMap32ATo32W },
+    { NULL, HOOK_UnMap32WTo32A, NULL }
+};
+
+
+/***********************************************************************
+ *           Internal Functions
+ */
+
+/***********************************************************************
+ *           HOOK_GetNextHook
+ *
+ * Get the next hook of a given hook.
+ */
+static HANDLE HOOK_GetNextHook( HANDLE hook )
+{
+    HOOKDATA *data = (HOOKDATA *)hook;
+
+    if (!data || !hook) return 0;
+    if (data->next) return data->next;
+    if (!data->ownerThread) return 0;  /* Already system hook */
+
+    /* Now start enumerating the system hooks */
+    return HOOK_systemHooks[data->id - WH_MINHOOK];
+}
+
+
+/***********************************************************************
+ *           HOOK_GetHook
+ *
+ * Get the first hook for a given type.
+ */
+static HANDLE HOOK_GetHook( INT id, DWORD threadId )
+{
+  MESSAGEQUEUE *queue;
+  HANDLE hook = 0;
+  THDB *thdb;
+    
+    thdb = GetTHDBFromThreadId(threadId);
+    if(thdb) {
+        hook = thdb->hooks[id - WH_MINHOOK];
+    }
+    if (!hook) hook = HOOK_systemHooks[id - WH_MINHOOK];
+
+    return hook;
+}
+
+
+/***********************************************************************
+ *           HOOK_SetHook
+ *
+ * Install a given hook.
+ */
+static HHOOK HOOK_SetHook( INT id, LPVOID proc, INT type,
+                           HMODULE hModule, DWORD dwThreadId )
+{
+  HOOKDATA *data;
+  THDB     *thdb;
+  
+    if ((id < WH_MINHOOK) || (id > WH_MAXHOOK) || !proc )
+    {
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return 0;
+    }
+
+    dprintf(("Setting hook %d: %08x %04x %08lx\n",
+             id, (UINT)proc, hModule, dwThreadId ));
+
+#ifndef __WIN32OS2__
+    /* Create task queue if none present */
+    GetFastQueue16();
+
+    if (id == WH_JOURNALPLAYBACK) EnableHardwareInput16(FALSE);
 #endif
-                return((HHOOK)hkhook);
+
+
+    if (dwThreadId)  /* Task-specific hook */
+    {
+        if ((id == WH_JOURNALRECORD) || (id == WH_JOURNALPLAYBACK) ||
+            (id == WH_SYSMSGFILTER)) {
+                SetLastError(ERROR_INVALID_PARAMETER);
+                return 0;  /* System-only hooks */
         }
-        case WH_DEBUG:
-                os2hkprc = HkDebug::GetOS2Hook();       
-                break;
-        case WH_JOURNALPLAYBACK:
-                os2hkprc = HkJrnlPlayback::GetOS2Hook();        
-                break;
-        case WH_JOURNALRECORD:
-                os2hkprc = HkJrnlRecord::GetOS2Hook();  
-                break;
-        case WH_GETMESSAGE:
-                os2hkprc = HkGetMessage::GetOS2Hook();  
-                break;
-        case WH_MOUSE:
-                os2hkprc = HkMouse::GetOS2Hook();       
-                break;
-        case WH_KEYBOARD:
-                os2hkprc = HkKeyboard::GetOS2Hook();    
-                break;
-        case WH_SHELL:
-                os2hkprc = HkShell::GetOS2Hook();       
-                break;
-        case WH_SYSMSGFILTER:
-                os2hkprc = HkSysMsgFilter::GetOS2Hook();        
-                break;
-        case WH_MSGFILTER:
-                os2hkprc = HkMsgFilter::GetOS2Hook();   
-                break;
-    }
-
-    rc = O32_SetWindowsHookEx(idHook, os2hkprc, hmod, dwThreadId);
-
-    if(rc) {
-      switch(idHook) {
-        case WH_CALLWNDPROC:
-                new HkWindow(rc, hkprc, hmod, dwThreadId);
-                break;
-        case WH_CBT:
-                break;
-        case WH_DEBUG:
-                new HkDebug(rc, hkprc, hmod, dwThreadId);;      
-                break;
-        case WH_JOURNALPLAYBACK:
-                new HkJrnlPlayback(rc, hkprc, hmod, dwThreadId);;       
-                break;
-        case WH_JOURNALRECORD:
-                new HkJrnlRecord(rc, hkprc, hmod, dwThreadId);; 
-                break;
-        case WH_GETMESSAGE:
-                new HkGetMessage(rc, hkprc, hmod, dwThreadId);; 
-                break;
-        case WH_MOUSE:
-                new HkMouse(rc, hkprc, hmod, dwThreadId);;      
-                break;
-        case WH_KEYBOARD:
-                new HkKeyboard(rc, hkprc, hmod, dwThreadId);;   
-                break;
-        case WH_SHELL:
-                new HkShell(rc, hkprc, hmod, dwThreadId);;      
-                break;
-        case WH_SYSMSGFILTER:
-                new HkSysMsgFilter(rc, hkprc, hmod, dwThreadId);;       
-                break;
-        case WH_MSGFILTER:
-                new HkMsgFilter(rc, hkprc, hmod, dwThreadId);;  
-                break;
-      } 
-    }
-#ifdef DEBUG
-    WriteLog("OS2SetWindowsHookExA %X, %X, %X, %X, returned %X\n", idHook, hkprc, hmod, dwThreadId, rc);
+    }
+
+    /* Create the hook structure */
+
+    data = (HOOKDATA *) HeapAlloc(GetProcessHeap(), 0, sizeof(HOOKDATA));
+    data->proc        = (HOOKPROC)proc;
+    data->id          = id;
+    data->ownerThread = dwThreadId;
+    data->ownerModule = hModule;
+    data->flags       = type;
+    data->magic       = HOOK_MAGIC;
+
+    /* Insert it in the correct linked list */
+    if(dwThreadId)
+    {
+        thdb = GetTHDBFromThreadId(dwThreadId);
+        if(!thdb) {
+                dprintf(("HOOK_SetHook: can't find thread database for thread %x", dwThreadId));
+                return 0;
+        }
+        threadHookMutex.enter();
+        data->next = thdb->hooks[id - WH_MINHOOK];
+        thdb->hooks[id - WH_MINHOOK] = (DWORD)data;
+        threadHookMutex.leave();
+    }
+    else
+    {
+        systemHookMutex.enter();
+        data->next = HOOK_systemHooks[id - WH_MINHOOK];
+        HOOK_systemHooks[id - WH_MINHOOK] = (HANDLE)data;
+        systemHookMutex.leave();
+    }
+
+    return (HHOOK)data;
+}
+
+
+/***********************************************************************
+ *           HOOK_RemoveHook
+ *
+ * Remove a hook from the list.
+ */
+static BOOL HOOK_RemoveHook( HOOKDATA *data )
+{
+  HOOKDATA *prevHook;
+  THDB     *thdb;
+  VMutex   *hookMutex;
+
+    dprintf(("Removing hook %08x\n", data));
+   
+    if (data->flags & HOOK_INUSE)
+    {
+        /* Mark it for deletion later on */
+        dprintf(("Hook still running, deletion delayed\n" ));
+        data->flags |= HOOK_DELAYED_DELETE;
+        return TRUE;
+    }
+
+#ifndef __WIN32OS2__
+    if (data->id == WH_JOURNALPLAYBACK) EnableHardwareInput16(TRUE);
 #endif
-    return(rc);
-}
-//******************************************************************************
-//******************************************************************************
-HHOOK WIN32API SetWindowsHookA(int idHook, HOOKPROC hkprc)
-{
- HHOOK rc;
-
-    rc = SetWindowsHookExA(idHook, hkprc, NULL, 0);
-#ifdef DEBUG
-    WriteLog("OS2SetWindowsHookA %X, %X, returned %X\n", idHook, hkprc, rc);
+     
+    /* Remove it from the linked list */
+
+    if (data->ownerThread)
+    {
+        thdb = GetTHDBFromThreadId(data->ownerThread);
+        if(!thdb) {
+                dprintf(("HOOK_RemoveHook: can't find thread database for thread %x", data->ownerThread));
+                return FALSE;
+        }
+        hookMutex = &threadHookMutex;
+        hookMutex->enter();
+        prevHook = (HOOKDATA *)thdb->hooks[data->id - WH_MINHOOK];
+    }
+    else {
+        hookMutex = &systemHookMutex;
+        hookMutex->enter();
+        prevHook = (HOOKDATA *)HOOK_systemHooks[data->id - WH_MINHOOK];
+    }
+    while (prevHook && prevHook != data)
+        prevHook = (HOOKDATA *)prevHook->next;
+
+    if (!prevHook) {
+        hookMutex->leave();
+        return FALSE;
+    }
+    prevHook = (HOOKDATA *)data->next;
+    hookMutex->leave();
+
+    HeapFree(GetProcessHeap(), 0, (LPVOID)data );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           HOOK_FindValidHook
+ */
+static HANDLE HOOK_FindValidHook( HANDLE hook )
+{
+    HOOKDATA *data;
+
+    for (;;)
+    {
+        if (!(data = (HOOKDATA *)hook)) return 0;
+        if (data->proc) return hook;
+        hook = data->next;
+    }
+}
+
+
+/***********************************************************************
+ *           HOOK_CallHook
+ *
+ * Call a hook procedure.
+ */
+static LRESULT HOOK_CallHook( HANDLE hook, INT fromtype, INT code,
+                              WPARAM wParam, LPARAM lParam )
+{
+    MESSAGEQUEUE *queue;
+    HANDLE prevHook;
+    HOOKDATA *data = (HOOKDATA *)hook;
+    LRESULT ret;
+
+    WPARAM wParamOrig = wParam;
+    LPARAM lParamOrig = lParam;
+    HOOK_MapFunc MapFunc;
+    HOOK_UnMapFunc UnMapFunc;
+
+    MapFunc = HOOK_MapFuncs[fromtype][data->flags & HOOK_MAPTYPE];
+    UnMapFunc = HOOK_UnMapFuncs[fromtype][data->flags & HOOK_MAPTYPE];
+
+    if (MapFunc)
+      MapFunc( data->id, code, &wParam, &lParam );
+
+    /* Now call it */
+
+    data->flags |= HOOK_INUSE;
+
+    dprintf2(("Calling hook %04x: %d %08x %08lx\n", hook, code, wParam, lParam ));
+
+    ret = data->proc(code, wParam, lParam);
+
+    data->flags &= ~HOOK_INUSE;
+
+    if (UnMapFunc)
+      UnMapFunc( data->id, code, wParamOrig, lParamOrig, wParam, lParam );
+
+    if(data->flags & HOOK_DELAYED_DELETE) HOOK_RemoveHook( data );
+
+    return ret;
+}
+
+/***********************************************************************
+ *           Exported Functions & APIs
+ */
+
+/***********************************************************************
+ *           HOOK_IsHooked
+ *
+ * Replacement for calling HOOK_GetHook from other modules.
+ */
+BOOL HOOK_IsHooked( INT id )
+{
+    /* Hmmm. Use GetThreadQueue(0) instead of GetFastQueue() here to 
+       avoid queue being created if someone wants to merely check ... */
+
+    return HOOK_GetHook( id, GetCurrentThreadId() ) != 0;
+}
+
+/***********************************************************************
+ *           HOOK_CallHooks32A
+ *
+ * Call a hook chain.
+ */
+LRESULT HOOK_CallHooksA( INT id, INT code, WPARAM wParam,
+                           LPARAM lParam )
+{
+    HANDLE hook; 
+
+    if (!(hook = HOOK_GetHook( id, GetCurrentThreadId() ))) return 0;
+    if (!(hook = HOOK_FindValidHook(hook))) return 0;
+    return HOOK_CallHook( hook, HOOK_WIN32A, code, wParam, lParam );
+}
+
+/***********************************************************************
+ *           HOOK_CallHooks32W
+ *
+ * Call a hook chain.
+ */
+LRESULT HOOK_CallHooksW( INT id, INT code, WPARAM wParam,
+                           LPARAM lParam )
+{
+    HANDLE hook; 
+
+    if (!(hook = HOOK_GetHook( id, GetCurrentThreadId() ))) return 0;
+    if (!(hook = HOOK_FindValidHook(hook))) return 0;
+    return HOOK_CallHook( hook, HOOK_WIN32W, code, wParam,
+                          lParam );
+}
+
+
+#if 0
+/***********************************************************************
+ *           HOOK_ResetQueueHooks
+ */
+void HOOK_ResetQueueHooks( HQUEUE hQueue )
+{
+    MESSAGEQUEUE *queue;
+
+    if ((queue = (MESSAGEQUEUE *)QUEUE_Lock( hQueue )) != NULL)
+    {
+        HOOKDATA*       data;
+        HHOOK           hook;
+        int             id;
+        for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
+        {
+            hook = queue->hooks[id - WH_MINHOOK];
+            while( hook )
+            {
+                if( (data = (HOOKDATA *)hook) )
+                {
+                  data->ownerQueue = hQueue;
+                  hook = data->next;
+                } else break;
+            }
+        }
+
+        QUEUE_Unlock( queue );
+    }
+}
 #endif
-    return(rc);
-}
-//******************************************************************************
-//******************************************************************************
-HHOOK WIN32API SetWindowsHookExW(int idHook, HOOKPROC hkprc, HINSTANCE hmod, DWORD dwThreadId)
-{
-#ifdef DEBUG
-    WriteLog("OS2SetWindowsHookExW\n");
-#endif
-    return(SetWindowsHookExA(idHook, hkprc, hmod, dwThreadId));
-}
-//******************************************************************************
-//******************************************************************************
-BOOL WIN32API UnhookWindowsHookEx(HHOOK hook)
-{
-#ifdef DEBUG
-    WriteLog("OS2UnhookWindowsHookEx\n");
-#endif
-   
-    if(HkWindow::UnHookWindowsHook(hook) == FALSE)
-     if(HkCBT::UnHookWindowsHook(hook) == TRUE) {
-        return(TRUE);
-     }
-     else
-      if(HkGetMessage::UnHookWindowsHook(hook) == FALSE)
-       if(HkMsgFilter::UnHookWindowsHook(hook) == FALSE)
-        if(HkSysMsgFilter::UnHookWindowsHook(hook) == FALSE)
-         if(HkMouse::UnHookWindowsHook(hook) == FALSE)
-          if(HkKeyboard::UnHookWindowsHook(hook) == FALSE)
-           if(HkShell::UnHookWindowsHook(hook) == FALSE)
-            if(HkDebug::UnHookWindowsHook(hook) == FALSE)
-             if(HkJrnlPlayback::UnHookWindowsHook(hook) == FALSE)
-              if(HkJrnlRecord::UnHookWindowsHook(hook) == FALSE) {
-                dprintf(("Hook %X not found!\n", hook));
-              }
-    return O32_UnhookWindowsHookEx(hook);
-}
-//******************************************************************************
-//******************************************************************************
-BOOL WIN32API UnhookWindowsHook(int nCode, HOOKPROC hkproc)
-{
- HHOOK hook = 0;
-    
-    switch(nCode) {
-        case WH_CALLWNDPROC:
-                hook = HkWindow::FindHookProc(hkproc);  
-                break;
-        case WH_CBT:
-                hook = HkCBT::FindHookProc(hkproc);
-                break;
-        case WH_DEBUG:
-                hook = HkDebug::FindHookProc(hkproc);   
-                break;
-        case WH_JOURNALPLAYBACK:
-                hook = HkJrnlPlayback::FindHookProc(hkproc);    
-                break;
-        case WH_JOURNALRECORD:
-                hook = HkJrnlRecord::FindHookProc(hkproc);      
-                break;
-        case WH_GETMESSAGE:
-                hook = HkGetMessage::FindHookProc(hkproc);      
-                break;
-        case WH_MOUSE:
-                hook = HkMouse::FindHookProc(hkproc);   
-                break;
-        case WH_KEYBOARD:
-                hook = HkKeyboard::FindHookProc(hkproc);        
-                break;
-        case WH_SHELL:
-                hook = HkShell::FindHookProc(hkproc);
-                break;
-        case WH_SYSMSGFILTER:
-                hook = HkSysMsgFilter::FindHookProc(hkproc);    
-                break;
-        case WH_MSGFILTER:
-                hook = HkMsgFilter::FindHookProc(hkproc);       
-                break;
-    }
-#ifdef DEBUG
-    WriteLog("OS2UnhookWindowsHook %X\n", hook);
-#endif
-    if(hook == 0)
-        return(FALSE);
-
-    return O32_UnhookWindowsHookEx(hook);
-}
-//******************************************************************************
-//******************************************************************************
-LRESULT WIN32API CallNextHookEx(HHOOK arg1, int arg2, WPARAM arg3, LPARAM  arg4)
-{
- HkCBT *hook;
-
-#ifdef DEBUG
-    WriteLog("OS2CallNextHookEx\n");
-#endif
-    if((hook = HkCBT::FindHook(arg1)) != NULL) {
-                return hook->CallNextHook(arg1, arg2, arg3, arg4);
-    }
-    else        return O32_CallNextHookEx(arg1, arg2, arg3, arg4);
-}
-//******************************************************************************
-//TODO
-//******************************************************************************
-BOOL WIN32API CallMsgFilterA( LPMSG msg, int nCode)
-{
-#ifdef DEBUG
-    WriteLog("USER32:  CallMsgFilterA\n");
-#endif
-#if 0
-    if(HkSysMsgFilter::OS2HkCBTProc(msg->hwnd, nCode, 0, (LPARAM)msg))
-        return TRUE;
-
-    return HkMsgFilter::OS2HkCBTProc(hwnd, Msg, wParam, lParam);
-#else
-    return 0;
-#endif
-}
-//******************************************************************************
-//TODO
-//******************************************************************************
-BOOL WIN32API CallMsgFilterW( LPMSG msg, int nCode)
-{
-#ifdef DEBUG
-    WriteLog("USER32:  CallMsgFilterW\n");
-#endif
-#if 0
-    if(HkSysMsgFilter::OS2HkCBTProc(msg->hwnd, nCode, 0, (LPARAM)msg))
-        return TRUE;
-
-    return HkMsgFilter::OS2HkCBTProc(hwnd, Msg, wParam, lParam);
-#else
-    return 0;
-#endif
-}
-//******************************************************************************
-//******************************************************************************
+
+/***********************************************************************
+ *           HOOK_FreeModuleHooks
+ */
+void HOOK_FreeModuleHooks( HMODULE hModule )
+{
+ /* remove all system hooks registered by this module */
+
+  HOOKDATA*     hptr;
+  HHOOK         hook, next;
+  int           id;
+
+  for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
+    {
+       hook = HOOK_systemHooks[id - WH_MINHOOK];
+       while( hook )
+          if( (hptr = (HOOKDATA *)hook) )
+            {
+              next = hptr->next;
+              if( hptr->ownerModule == hModule )
+                {
+                  hptr->flags &= HOOK_MAPTYPE;
+                  HOOK_RemoveHook(hptr);
+                }
+              hook = next;
+            }
+          else hook = 0;
+    }
+}
+
+/***********************************************************************
+ *           HOOK_FreeQueueHooks
+ */
+void HOOK_FreeQueueHooks( DWORD threadId )
+{
+  /* remove all hooks registered by this queue */
+
+  HOOKDATA*     hptr = NULL;
+  HHOOK         hook, next;
+  int           id;
+
+  for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
+    {
+       hook = HOOK_GetHook( id, threadId );
+       while( hook )
+        {
+          next = HOOK_GetNextHook(hook);
+
+          hptr = (HOOKDATA *)hook;
+          if( hptr && hptr->ownerThread == threadId )
+            {
+              hptr->flags &= HOOK_MAPTYPE;
+              HOOK_RemoveHook(hptr);
+            }
+          hook = next;
+        }
+    }
+}
+
+
+/***********************************************************************
+ *           SetWindowsHook32A   (USER32.525)
+ */
+HHOOK WINAPI SetWindowsHookA( INT id, HOOKPROC proc )
+{
+    return SetWindowsHookExA( id, proc, 0, GetCurrentThreadId() );
+}
+
+/***********************************************************************
+ *           SetWindowsHook32W   (USER32.528)
+ */
+HHOOK WINAPI SetWindowsHookW( INT id, HOOKPROC proc )
+{
+    return SetWindowsHookExW( id, proc, 0, GetCurrentThreadId() );
+}
+
+/***********************************************************************
+ *           SetWindowsHookEx32A   (USER32.526)
+ */
+HHOOK WINAPI SetWindowsHookExA( INT id, HOOKPROC proc, HINSTANCE hInst,
+                                  DWORD dwThreadId )
+{
+    return HOOK_SetHook( id, proc, HOOK_WIN32A, hInst, dwThreadId );
+}
+
+/***********************************************************************
+ *           SetWindowsHookEx32W   (USER32.527)
+ */
+HHOOK WINAPI SetWindowsHookExW( INT id, HOOKPROC proc, HINSTANCE hInst,
+                                  DWORD dwThreadId )
+{
+    return HOOK_SetHook( id, proc, HOOK_WIN32W, hInst, dwThreadId );
+}
+
+/***********************************************************************
+ *           UnhookWindowsHook32   (USER32.557)
+ */
+BOOL WINAPI UnhookWindowsHook( INT id, HOOKPROC proc )
+{
+    HANDLE hook = HOOK_GetHook( id, GetCurrentThreadId() );
+
+    dprintf(("UnhookWindowsHook: %d %08lx\n", id, (DWORD)proc ));
+
+    while (hook)
+    {
+        HOOKDATA *data = (HOOKDATA *)hook;
+        if (data->proc == proc) break;
+        hook = HOOK_GetNextHook( hook );
+    }
+    if (!hook) return FALSE;
+    return HOOK_RemoveHook( (HOOKDATA *)hook );
+}
+
+
+/***********************************************************************
+ *           UnhookWindowHookEx32   (USER32.558)
+ */
+BOOL WINAPI UnhookWindowsHookEx( HHOOK hhook )
+{
+    if (CHECK_MAGIC(hhook) == FALSE)
+        return FALSE;
+
+    return HOOK_RemoveHook( (HOOKDATA *)hhook );
+}
+
+/***********************************************************************
+ *           CallNextHookEx32    (USER32.17)
+ *
+ * There aren't ANSI and UNICODE versions of this.
+ */
+LRESULT WINAPI CallNextHookEx( HHOOK hhook, INT code, WPARAM wParam,
+                                 LPARAM lParam )
+{
+    HANDLE next;
+    INT fromtype;       /* figure out Ansi/Unicode */
+    HOOKDATA *oldhook;
+
+    if (CHECK_MAGIC(hhook) == FALSE)
+        return FALSE;
+
+    if (!(next = HOOK_GetNextHook( hhook ))) return 0;
+
+    oldhook = (HOOKDATA *)hhook ;
+    fromtype = oldhook->flags & HOOK_MAPTYPE;
+
+    return HOOK_CallHook( next, fromtype, code, wParam, lParam );
+}
+
+
+/***********************************************************************
+ *           CallMsgFilter32A   (USER32.15)
+ */
+/*
+ * FIXME: There are ANSI and UNICODE versions of this, plus an unspecified
+ * version, plus USER (the 16bit one) has a CallMsgFilter32 function.
+ */
+BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
+{
+    if (GetSysModalWindow()) return FALSE;      /* ??? */
+    if (HOOK_CallHooksA( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
+      return TRUE;
+    return HOOK_CallHooksA( WH_MSGFILTER, code, 0, (LPARAM)msg );
+}
+
+
+/***********************************************************************
+ *           CallMsgFilter32W   (USER32.16)
+ */
+BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
+{
+    if (GetSysModalWindow()) return FALSE;      /* ??? */
+    if (HOOK_CallHooksW( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
+      return TRUE;
+    return HOOK_CallHooksW( WH_MSGFILTER, code, 0, (LPARAM)msg );
+}
+

trunk/src/user32/Makefile

@@ -1 @@
-# $Id: Makefile,v 1.47 1999-12-09 00:53:36 sandervl Exp $
+# $Id: Makefile,v 1.48 1999-12-16 00:11:45 sandervl Exp $
 
 #
@@ -31 +31 @@
 OBJS =  user32.obj loadres.obj \
         dde.obj win32wndhandle.obj wsprintf.obj winmouse.obj \
-        icon.obj hook.obj hooks.obj winmenu.obj winkeyboard.obj \
+        icon.obj hook.obj winmenu.obj winkeyboard.obj \
         defwndproc.obj syscolor.obj char.obj initterm.obj \
         uitools.obj unknown.obj spy.obj wndmsg.obj display.obj \
@@ -96 +96 @@
 syscolor.obj: syscolor.cpp syscolor.h
 dde.obj: dde.cpp
-hook.obj: hook.cpp hooks.h
+hook.obj: hook.cpp $(PDWIN32_INCLUDE)\win\hook.h
 defwndproc.obj: defwndproc.cpp syscolor.h win32wmdiclient.h win32wbase.h win32wnd.h win32dlg.h
-hooks.obj: hooks.cpp hooks.h
 initterm.obj: initterm.cpp $(PDWIN32_INCLUDE)\spy.h pmwindow.h initterm.h
 uitools.obj: uitools.cpp win32wbase.h
@@ -130 +129 @@
 pmframe.obj: pmframe.cpp win32class.h win32wbase.h pmframe.h win32wndchild.h
 win32class.obj: win32class.cpp win32class.h win32wbase.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h $(PDWIN32_INCLUDE)\win\winproc.h
-win32wbase.obj:   win32wbase.cpp win32class.h win32wbase.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h  $(PDWIN32_INCLUDE)\winres.h oslibres.h win32wndhandle.h oslibdos.h dc.h pmframe.h win32wdesktop.h controls.h winmouse.h $(PDWIN32_INCLUDE)\win\winproc.h
+win32wbase.obj:   win32wbase.cpp win32class.h win32wbase.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h  $(PDWIN32_INCLUDE)\winres.h oslibres.h win32wndhandle.h oslibdos.h dc.h pmframe.h win32wdesktop.h controls.h winmouse.h $(PDWIN32_INCLUDE)\win\winproc.h $(PDWIN32_INCLUDE)\win\hook.h
 win32wbasepos.obj: win32wbasepos.cpp win32class.h win32wbase.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h  $(PDWIN32_INCLUDE)\winres.h oslibres.h win32wndhandle.h oslibdos.h dc.h pmframe.h win32wdesktop.h
 win32wnd.obj:   win32wnd.cpp win32class.h win32wbase.h win32wnd.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h  $(PDWIN32_INCLUDE)\winres.h oslibres.h win32wndhandle.h oslibdos.h oslibmenu.h

trunk/src/user32/pmwindow.cpp

@@ -1 @@
-/* $Id: pmwindow.cpp,v 1.64 1999-12-14 19:13:19 sandervl Exp $ */
+/* $Id: pmwindow.cpp,v 1.65 1999-12-16 00:11:45 sandervl Exp $ */
 /*
  * Win32 Window Managment Code for OS/2
@@ -214 +214 @@
   if(msg == WIN32APP_POSTMSG && (ULONG)mp1 == WIN32PM_MAGIC) {
         //win32 app user message
-        win32wnd->PostMessage((POSTMSG_PACKET *)mp2);
-        return (MRESULT)0;
+        return (MRESULT)win32wnd->PostMessage((POSTMSG_PACKET *)mp2);;
   }
   switch( msg )
@@ -417 +416 @@
         break;
     }
-
+    case WM_MINMAXFRAME:
+    {
+        dprintf(("OS2: WM_MINMAXFRAME"));
+        break;
+    }
     case WM_OWNERPOSCHANGE:
     {

trunk/src/user32/user32.cpp

@@ -1 @@
-/* $Id: user32.cpp,v 1.58 1999-12-03 20:40:09 phaller Exp $ */
+/* $Id: user32.cpp,v 1.59 1999-12-16 00:11:45 sandervl Exp $ */
 
 /*
@@ -2676 +2676 @@
 /* Hook Functions */
 
-/*****************************************************************************
- * Name      : BOOL WIN32API SetWindowsHookW
- * Purpose   : The SetWindowsHook function is not implemented in the Win32 API.
- *             Win32-based applications should use the SetWindowsHookEx function.
- * Parameters:
- * Variables :
- * Result    :
- * Remark    : ARGH ! MICROSOFT !
- * Status    : UNTESTED STUB
- *
- * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
- *****************************************************************************/
-HHOOK WIN32API SetWindowsHookW(int nFilterType, HOOKPROC pfnFilterProc)
-
-{
-  return (FALSE);
-}
-
-/* CB: move to ShowWindow() */
-
-/*****************************************************************************
- * Name      : BOOL WIN32API ShowWindowAsync
- * Purpose   : The ShowWindowAsync function sets the show state of a window
- *             created by a different thread.
- * Parameters: HWND hwnd     handle of window
- *             int  nCmdShow show state of window
- * Variables :
- * Result    : If the window was previously visible, the return value is TRUE.
- *             If the window was previously hidden, the return value is FALSE.
- * Remark    :
- * Status    : UNTESTED STUB
- *
- * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
- *****************************************************************************/
-BOOL WIN32API ShowWindowAsync (HWND hWnd,
-                               int  nCmdShow)
-{
-  dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not implemented.\n",
-         hWnd,
-         nCmdShow));
-
-  return (FALSE);
-}
-
 /* CB: move to MDI */
 

trunk/src/user32/win32dlg.cpp

@@ -1 @@
-/* $Id: win32dlg.cpp,v 1.36 1999-12-09 00:53:37 sandervl Exp $ */
+/* $Id: win32dlg.cpp,v 1.37 1999-12-16 00:11:46 sandervl Exp $ */
 /*
  * Win32 Dialog Code for OS/2
@@ -217 +217 @@
 
     if (hUserFont)
-        SendMessageA(WM_SETFONT, (WPARAM)hUserFont, 0 );
+        SendInternalMessageA(WM_SETFONT, (WPARAM)hUserFont, 0 );
 
     /* Create controls */
@@ -226 +226 @@
         hwndFocus = GetNextDlgTabItem( getWindowHandle(), 0, FALSE );
 
-        if (SendMessageA(WM_INITDIALOG, (WPARAM)hwndFocus, param))
+        if (SendInternalMessageA(WM_INITDIALOG, (WPARAM)hwndFocus, param))
              SetFocus(hwndFocus);
 
@@ -262 +262 @@
     /* Owner must be a top-level window */
     if(getOwner() == NULL) {
-     topOwner = windowDesktop;
+         topOwner = windowDesktop;
     }
     else topOwner = getOwner()->GetTopParent();
@@ -295 +295 @@
           if (!OSLibWinPeekMsg(&msg,0,0,0,MSG_NOREMOVE))
           {
-            if(!(getStyle() & DS_NOIDLEMSG))
-              topOwner->SendMessageA(WM_ENTERIDLE,MSGF_DIALOGBOX,getWindowHandle());
-            OSLibWinGetMsg(&msg,0,0,0);
-          } else OSLibWinPeekMsg(&msg,0,0,0,MSG_REMOVE);
+                if(!(getStyle() & DS_NOIDLEMSG))
+                    topOwner->SendMessageA(WM_ENTERIDLE,MSGF_DIALOGBOX,getWindowHandle());
+                OSLibWinGetMsg(&msg,0,0,0);
+          }
+          else  OSLibWinPeekMsg(&msg,0,0,0,MSG_REMOVE);
 
           if(msg.message == WM_QUIT)
           {
-            dprintf(("Win32Dialog::doDialogBox: received  WM_QUIT"));
-            break;
+                dprintf(("Win32Dialog::doDialogBox: received  WM_QUIT"));
+                break;
           }
           if (!IsDialogMessageA( getWindowHandle(), &msg))
           {
-            TranslateMessage( &msg );
-            DispatchMessageA( &msg );
+                TranslateMessage( &msg );
+                DispatchMessageA( &msg );
           }
-          if (dialogFlags & DF_END) break;
+          if (dialogFlags & DF_END)
+                break;
         }
 #else
@@ -332 +334 @@
             else {
                 if(!(getStyle() & DS_NOIDLEMSG)) {
-                    topOwner->SendMessageA(WM_ENTERIDLE, MSGF_DIALOGBOX, getWindowHandle());
+                    topOwner->SendInternalMessageA(WM_ENTERIDLE, MSGF_DIALOGBOX, getWindowHandle());
                 }
             }
@@ -1030 +1032 @@
     {
     case DWL_DLGPROC:
-            oldval = (LONG)WINPROC_GetProc(Win32DlgProc, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A);
+        oldval = (LONG)WINPROC_GetProc(Win32DlgProc, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A);
         WINPROC_SetProc((HWINDOWPROC *)&Win32DlgProc, (WNDPROC)value, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A, WIN_PROC_WINDOW);
         return oldval;
@@ -1053 +1055 @@
     {
     case DWL_DLGPROC:
-            return (ULONG)WINPROC_GetProc(Win32DlgProc, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A);
+        return (ULONG)WINPROC_GetProc(Win32DlgProc, (fUnicode) ? WIN_PROC_32W : WIN_PROC_32A);
     case DWL_MSGRESULT:
         return msgResult;

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:

trunk/src/user32/win32wbase.h

@@ -1 @@
-/* $Id: win32wbase.h,v 1.53 1999-12-14 19:13:20 sandervl Exp $ */
+/* $Id: win32wbase.h,v 1.54 1999-12-16 00:11:47 sandervl Exp $ */
 /*
  * Win32 Window Base Class for OS/2
@@ -40 +40 @@
 
 #define WIN32APP_USERMSGBASE      0x1000
-#define WIN32APP_POSTMSG          0x6666
+#define WIN32APP_POSTMSG          0x1000
 
 typedef struct
@@ -49 +49 @@
         ULONG           fUnicode;
 } POSTMSG_PACKET;
-
-#define WM_WIN32_POSTMESSAGEA   0x4000
-#define WM_WIN32_POSTMESSAGEW   0x4001
 
 #define BROADCAST_SEND          0
@@ -213 +210 @@
        LRESULT  SendMessageA(ULONG msg, WPARAM wParam, LPARAM lParam);
        LRESULT  SendMessageW(ULONG msg, WPARAM wParam, LPARAM lParam);
-       LRESULT  SendMessageToProcess(UINT msg, WPARAM wParam, LPARAM lParam, BOOL fUnicode);
        BOOL     PostMessageA(ULONG msg, WPARAM wParam, LPARAM lParam);
        BOOL     PostMessageW(ULONG msg, WPARAM wParam, LPARAM lParam);
-       void     PostMessage(POSTMSG_PACKET *packet);
+       ULONG    PostMessage(POSTMSG_PACKET *packet);
 static BOOL     PostThreadMessageA(ULONG threadid, UINT msg, WPARAM wParam, LPARAM lParam);
 static BOOL     PostThreadMessageW(ULONG threadid, UINT msg, WPARAM wParam, LPARAM lParam);
 static LRESULT  BroadcastMessageA(int type, UINT msg, WPARAM wParam, LPARAM lParam);
 static LRESULT  BroadcastMessageW(int type, UINT msg, WPARAM wParam, LPARAM lParam);
+       void     CallWindowHookProc(ULONG hooktype, ULONG Msg, WPARAM wParam, LPARAM lParam, BOOL fUnicode = FALSE);
 
        LRESULT  DefWindowProcA(UINT Msg, WPARAM wParam, LPARAM lParam);
@@ -306 +303 @@
         BOOL    fNoSizeMsg;
         BOOL    fIsDestroyed;
+        BOOL    fDestroyWindowCalled;   //DestroyWindow was called for this window
         BOOL    fCreated;
         BOOL    fTaskList;              //should be listed in PM tasklist or not
         BOOL    fParentDC;
 
+        DWORD   dwThreadId;             //id of thread that created this window
+        DWORD   dwProcessId;            //id of process that created this window
         PVOID   pOldFrameProc;
         ULONG   borderWidth;

trunk/src/user32/win32wbasepos.cpp

@@ -1 @@
-/* $Id: win32wbasepos.cpp,v 1.6 1999-10-28 12:00:35 sandervl Exp $ */
+/* $Id: win32wbasepos.cpp,v 1.7 1999-12-16 00:11:47 sandervl Exp $ */
 /*
  * Win32 Window Base Class for OS/2 (nonclient/position methods)
@@ -28 +28 @@
 #include <spy.h>
 #include "wndmsg.h"
-#include "hooks.h"
 #include "oslibwin.h"
 #include "oslibutil.h"
@@ -94 +93 @@
     if( dwStyle & WS_MINIMIZE )
     {
-        if( !SendMessageA(WM_QUERYOPEN, 0, 0L ) )
+        if( !SendInternalMessageA(WM_QUERYOPEN, 0, 0L ) )
         return (SWP_NOSIZE | SWP_NOMOVE);
         swpFlags |= SWP_NOCOPYBITS;
@@ -232 +231 @@
 //    }
 
-    SendMessageA(WM_GETMINMAXINFO, 0, (LPARAM)&MinMax );
+    SendInternalMessageA(WM_GETMINMAXINFO, 0, (LPARAM)&MinMax );
 
       /* Some sanity checks */
@@ -276 +275 @@
         params.lppos = &winposCopy;
    }
-   result = SendMessageA(WM_NCCALCSIZE, calcValidRect,
+   result = SendInternalMessageA(WM_NCCALCSIZE, calcValidRect,
                          (LPARAM)&params );
    *newClientRect = params.rgrc[0];

trunk/src/user32/win32wmdichild.cpp

@@ -1 @@
-/* $Id: win32wmdichild.cpp,v 1.11 1999-12-14 19:13:20 sandervl Exp $ */
+/* $Id: win32wmdichild.cpp,v 1.12 1999-12-16 00:11:48 sandervl Exp $ */
 /*
  * Win32 MDI Child Window Class for OS/2
@@ -30 +30 @@
 #include <spy.h>
 #include "wndmsg.h"
-#include "hooks.h"
 #include <oslibwin.h>
 #include <oslibutil.h>
@@ -231 +230 @@
         if (wParam == '-')
         {
-            SendMessageA(WM_SYSCOMMAND, (WPARAM)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
+            SendInternalMessageA(WM_SYSCOMMAND, (WPARAM)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
             return 0;
         }
@@ -268 +267 @@
         if (wParam == '-')
         {
-            SendMessageW(WM_SYSCOMMAND, SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
+            SendInternalMessageW(WM_SYSCOMMAND, SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
             return 0;
         }

trunk/src/user32/win32wmdiclient.cpp

@@ -1 @@
-/* $Id: win32wmdiclient.cpp,v 1.13 1999-12-09 10:59:05 sandervl Exp $ */
+/* $Id: win32wmdiclient.cpp,v 1.14 1999-12-16 00:11:48 sandervl Exp $ */
 /*
  * Win32 MDI Client Window Class for OS/2
@@ -26 +26 @@
 #include <spy.h>
 #include "wndmsg.h"
-#include "hooks.h"
 #include <oslibwin.h>
 #include <oslibutil.h>
@@ -223 +222 @@
     case WM_NCACTIVATE:
         if( activeChild )
-            activeChild->SendMessageA(message, wParam, lParam);
+            activeChild->SendInternalMessageA(message, wParam, lParam);
         break;
 
@@ -344 +343 @@
     {
         prevActive->setStyle(prevActive->getStyle() | WS_SYSMENU);
-        prevActive->SendMessageA( WM_NCACTIVATE, FALSE, 0L );
-        prevActive->SendMessageA( WM_MDIACTIVATE, (WPARAM)prevActive->getWindowHandle(), (LPARAM)(child) ? child->getWindowHandle() : 0);
+        prevActive->SendInternalMessageA( WM_NCACTIVATE, FALSE, 0L );
+        prevActive->SendInternalMessageA( WM_MDIACTIVATE, (WPARAM)prevActive->getWindowHandle(), (LPARAM)(child) ? child->getWindowHandle() : 0);
 
         /* uncheck menu item */
@@ -386 +385 @@
     if( isActiveFrameWnd )
     {
-        child->SendMessageA( WM_NCACTIVATE, TRUE, 0L);
+        child->SendInternalMessageA( WM_NCACTIVATE, TRUE, 0L);
         if( GetFocus() == getWindowHandle())
-            SendMessageA( WM_SETFOCUS, (WPARAM)getWindowHandle(), 0L );
+            SendInternalMessageA( WM_SETFOCUS, (WPARAM)getWindowHandle(), 0L );
         else
             SetFocus( getWindowHandle() );
@@ -394 +393 @@
 
     /* @@@PH prevActive may be NULL actually ?! */
-    child->SendMessageA( WM_MDIACTIVATE,
+    child->SendInternalMessageA( WM_MDIACTIVATE,
                          prevActive ? (WPARAM)prevActive->getWindowHandle() : 0,
                          child->getWindowHandle());
@@ -602 +601 @@
 }
 /**********************************************************************
- *                                      MDI_RestoreFrameMenu
+ *                  MDI_RestoreFrameMenu
  */
 BOOL Win32MDIClientWindow::restoreFrameMenu(Win32BaseWindow *child)
@@ -611 +610 @@
 
     if(!(iId == SC_RESTORE || iId == SC_CLOSE) )
-            return 0;
+        return 0;
 
     /*
@@ -621 +620 @@
 
     GetMenuItemInfoA(getParent()->GetMenu(),
-                             0,
-                             TRUE,
-                             &menuInfo);
+                     0,
+                     TRUE,
+                     &menuInfo);
 
     RemoveMenu(getParent()->GetMenu(),0,MF_BYPOSITION);
@@ -630 +629 @@
 #if 0
     if ((menuInfo.fType & MFT_BITMAP)           &&
-            (LOWORD(menuInfo.dwTypeData)!=0)        &&
-            (LOWORD(menuInfo.dwTypeData)!=hBmpClose) )
+        (LOWORD(menuInfo.dwTypeData)!=0)        &&
+        (LOWORD(menuInfo.dwTypeData)!=hBmpClose) )
     {
         DeleteObject((HBITMAP)LOWORD(menuInfo.dwTypeData));
@@ -660 +659 @@
 
     if (getMaximizedChild())
-        SendMessageA(WM_MDIRESTORE, (WPARAM)getMaximizedChild()->getWindowHandle(), 0);
+        SendInternalMessageA(WM_MDIRESTORE, (WPARAM)getMaximizedChild()->getWindowHandle(), 0);
 
     if (nActiveChildren == 0) return 0;
@@ -706 +705 @@
 
     if (getMaximizedChild())
-        SendMessageA(WM_MDIRESTORE, (WPARAM)getMaximizedChild()->getWindowHandle(), 0);
+        SendInternalMessageA(WM_MDIRESTORE, (WPARAM)getMaximizedChild()->getWindowHandle(), 0);
 
     if (nActiveChildren == 0) return;

trunk/src/user32/win32wnd.cpp

@@ -1 @@
-/* $Id: win32wnd.cpp,v 1.2 1999-10-28 12:00:37 sandervl Exp $ */
+/* $Id: win32wnd.cpp,v 1.3 1999-12-16 00:11:48 sandervl Exp $ */
 /*
  * Win32 Window Class for OS/2
@@ -25 +25 @@
 #include <spy.h>
 #include "wndmsg.h"
-#include "hooks.h"
 #include <oslibwin.h>
 #include <oslibutil.h>

trunk/src/user32/window.cpp

@@ -1 @@
-/* $Id: window.cpp,v 1.41 1999-12-09 00:53:38 sandervl Exp $ */
+/* $Id: window.cpp,v 1.42 1999-12-16 00:11:48 sandervl Exp $ */
 /*
  * Win32 window apis for OS/2
@@ -394 +394 @@
 {
   Win32BaseWindow *window;
+  BOOL rc;
 
     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
@@ -401 +402 @@
         return 0;
     }
-    dprintf(("IsIconic %x", hwnd));
-    return window->IsIconic();
+    rc = window->IsIconic();
+    dprintf(("IsIconic %x returned %d", hwnd, rc));
+    return rc;
 }
 //******************************************************************************
@@ -461 +463 @@
     dprintf(("ShowWindow %x", hwnd));
     return window->ShowWindow(nCmdShow);
+}
+/*****************************************************************************
+ * Name      : BOOL WIN32API ShowWindowAsync
+ * Purpose   : The ShowWindowAsync function sets the show state of a window
+ *             created by a different thread.
+ * Parameters: HWND hwnd     handle of window
+ *             int  nCmdShow show state of window
+ * Variables :
+ * Result    : If the window was previously visible, the return value is TRUE.
+ *             If the window was previously hidden, the return value is FALSE.
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
+ *****************************************************************************/
+BOOL WIN32API ShowWindowAsync (HWND hwnd,
+                               int  nCmdShow)
+{
+  dprintf(("USER32:ShowWindowAsync (%08xh,%08x) not correctly implemented.\n",
+         hwnd,
+         nCmdShow));
+
+  return ShowWindow(hwnd, nCmdShow);
 }
 //******************************************************************************

trunk/src/user32/windowmsg.cpp

@@ -1 @@
-/* $Id: windowmsg.cpp,v 1.9 1999-12-09 00:53:38 sandervl Exp $ */
+/* $Id: windowmsg.cpp,v 1.10 1999-12-16 00:11:49 sandervl Exp $ */
 /*
  * Win32 window message APIs for OS/2
@@ -20 +20 @@
 #include <win32wbase.h>
 #include <win.h>
-#include <hooks.h>
 #include <heapstring.h>
 #include "oslibwin.h"

trunk/src/user32/winmenu.cpp

@@ -1 @@
-/* $Id: winmenu.cpp,v 1.17 1999-11-14 12:00:01 sandervl Exp $ */
+/* $Id: winmenu.cpp,v 1.18 1999-12-16 00:11:49 sandervl Exp $ */
 
 /*
@@ -597 +597 @@
               UINT, arg3)
 {
-    dprintf(("USER32:  OS2CheckMenuItem\n"));
     if(hMenu == 0)
     {