Add CallWindowProc to User32

Author: heldplayer

CHANGES.md

@@ -10,6 +10,7 @@ Features
 * [#1217](https://github.com/java-native-access/jna/pull/1217): Add mappings for AIX `Perfstat` library to `c.s.j.p.unix.aix` - [@dbwiddis](https://github.com/dbwiddis).
 * [#1231](https://github.com/java-native-access/jna/pull/1231): The test suite can now be executed on Windows using either ANSI or UNICODE win32 API by passing `-Dw32.ascii=true/false` to ant. Previously, UNICODE was always used. - [@T-Svensson](https://github.com/T-Svensson/)
 * [#1237](https://github.com/java-native-access/jna/pull/1237): *Experimental:* Add artifacts that make jna and jna-platform named modules (provide `module-info.class`). The new artifacts are named `jna-jpms.jar` and `jna-platform-jpms.jar` - [@matthiasblaesing](https://github.com/matthiasblaesing).
+* [#1242](https://github.com/java-native-access/jna/pull/1242): Add CallWindowProc to User32 - [@heldplayer](https://github.com/heldplayer).
 
 Bug Fixes
 ---------

contrib/platform/src/com/sun/jna/platform/win32/User32.java

@@ -1606,6 +1606,38 @@ HWND CreateWindowEx(int dwExStyle, String lpClassName,
      */
     boolean GetClassInfoEx(HINSTANCE hinst, String lpszClass, WNDCLASSEX lpwcx);
 
+    /**
+     * Passes message information to the specified window procedure.
+     *
+     * @param lpPrevWndFunc
+     *            The previous window procedure. If this value is obtained by calling
+     *            the GetWindowLong function with the nIndex parameter set to GWL_WNDPROC
+     *            or DWL_DLGPROC, it is actually either the address of a window or dialog
+     *            box procedure, or a special internal value meaningful only to
+     *            CallWindowProc.
+     *
+     * @param hWnd
+     *            A handle to the window procedure to receive the message.
+     *
+     * @param Msg
+     *            The message.
+     *
+     * @param wParam
+     *            Additional message information. The content of this parameter
+     *            depends on the value of the Msg parameter.
+     *
+     * @param lParam
+     *            Additional message information. The content of this parameter
+     *            depends on the value of the Msg parameter.
+     *
+     * @return The return value is the result of the message processing and depends on
+     *         the message.
+     *         <p>
+     *         If the function fails, the return value is zero. To get extended
+     *         error information, call {@link Kernel32#GetLastError}.
+     */
+    LRESULT CallWindowProc(Pointer lpPrevWndFunc, HWND hWnd, int Msg, WPARAM wParam, LPARAM lParam);
+
     /**
      * Calls the default window procedure to provide default processing for any
      * window messages that an application does not process. This function

contrib/platform/test/com/sun/jna/platform/win32/User32WindowMessagesTest.java

@@ -31,6 +31,7 @@
 import org.junit.Test;
 import org.junit.runner.JUnitCore;
 
+import com.sun.jna.CallbackReference;
 import com.sun.jna.Native;
 import com.sun.jna.Pointer;
 import com.sun.jna.Structure;
@@ -106,6 +107,24 @@ public void testWindowMesssages() {
             log("User Message sent to hooked proc " + hwndPing + ", result = " + result);
             assertEquals(0, result.intValue());
 
+            // DEMO 4 : subclass the window to return a different value when receiving MSG_SIMPLE_CODE
+            // First make sure we remove the hook
+            User32.INSTANCE.UnhookWindowsHookEx(hook);
+            hook = null;
+
+            subclassProc(hwndPing);
+            result = User32.INSTANCE.SendMessage(hwndPing, WinUser.WM_USER, new WPARAM(MSG_SIMPLE_CODE),
+                    new LPARAM(MSG_SIMPLE_VAL));
+            log("User Message sent to subclassed " + hwndPing + ", result = " + result);
+            assertEquals(0xC0FE, result.intValue());
+
+            // Then we check if this still works with a hooked proc as well
+            hook = hookwinProc(hwndPing);
+            result = User32.INSTANCE.SendMessage(hwndPing, WinUser.WM_USER, new WPARAM(MSG_HOOKED_CODE),
+                    new LPARAM(MSG_HOOKED_VAL));
+            log("User Message sent to hooked and subclassed proc " + hwndPing + ", result = " + result);
+            assertEquals(0, result.intValue());
+
             // Waits e few moment before shutdown message.
             sleepCurrThread(3000);
 
@@ -395,6 +414,38 @@ public LRESULT callback(int nCode, WPARAM wParam, LPARAM lParam) {
         return User32.INSTANCE.SetWindowsHookEx(WinUser.WH_CALLWNDPROC, hookProc, hInst, threadtoHook);
     }
 
+    private void subclassProc(HWND hwndToSubclass) {
+        class SubClassedWindowProc implements WindowProc {
+            private Pointer oldWindowProc;
+
+            @Override
+            public LRESULT callback(HWND hwnd, int uMsg, WPARAM wParam, LPARAM lParam) {
+                if (uMsg == WinUser.WM_USER) {
+                    log(hwnd + " - subclass received a WM_USER message with code : '" + wParam + "' and value : '" + lParam
+                            + "'");
+
+                    if (wParam.intValue() == MSG_SIMPLE_CODE) {
+                        // We also want to be sure the value is still the same passed
+                        assertEqualsForCallbackExecution(MSG_SIMPLE_VAL, lParam.intValue());
+
+                        return new LRESULT(0xC0FE);
+                    }
+                }
+                if (this.oldWindowProc != null) {
+                    return User32.INSTANCE.CallWindowProc(this.oldWindowProc, hwnd, uMsg, wParam, lParam);
+                } else {
+                    // In case the old pointer has not yet been set due to for example a race condition,
+                    // send the message to the default handler instead
+                    return User32.INSTANCE.DefWindowProc(hwnd, uMsg, wParam, lParam);
+                }
+            }
+        }
+
+        SubClassedWindowProc subclass = new SubClassedWindowProc();
+        subclass.oldWindowProc = User32.INSTANCE.SetWindowLongPtr(hwndToSubclass, WinUser.GWL_WNDPROC,
+                CallbackReference.getFunctionPointer(subclass));
+    }
+
     /**
      * Gets the last error.
      *