win32u: Move winproc array from user32.

dlls/user32/controls.h

@@ -22,6 +22,7 @@
 #define __WINE_CONTROLS_H
 
 #include "winuser.h"
+#include "../win32u/ntuser_private.h"
 
 /* Built-in class names (see _Undocumented_Windows_ p.418) */
 #define POPUPMENU_CLASS_ATOM MAKEINTATOM(32768)  /* PopupMenu */
@@ -30,31 +31,6 @@
 #define WINSWITCH_CLASS_ATOM MAKEINTATOM(32771)  /* WinSwitch */
 #define ICONTITLE_CLASS_ATOM MAKEINTATOM(32772)  /* IconTitle */
 
-enum builtin_winprocs
-{
-    /* dual A/W procs */
-    WINPROC_BUTTON = 0,
-    WINPROC_COMBO,
-    WINPROC_DEFWND,
-    WINPROC_DIALOG,
-    WINPROC_EDIT,
-    WINPROC_LISTBOX,
-    WINPROC_MDICLIENT,
-    WINPROC_SCROLLBAR,
-    WINPROC_STATIC,
-    WINPROC_IME,
-    /* unicode-only procs */
-    WINPROC_DESKTOP,
-    WINPROC_ICONTITLE,
-    WINPROC_MENU,
-    WINPROC_MESSAGE,
-    NB_BUILTIN_WINPROCS,
-    NB_BUILTIN_AW_WINPROCS = WINPROC_DESKTOP
-};
-
-#define WINPROC_HANDLE (~0u >> 16)
-#define BUILTIN_WINPROC(index) ((WNDPROC)(ULONG_PTR)((index) | (WINPROC_HANDLE << 16)))
-
 /* Built-in class descriptor */
 struct builtin_class_descr
 {

dlls/user32/user_main.c

@@ -169,6 +169,7 @@ static BOOL process_attach(void)
     NtUserCallOneParam( (UINT_PTR)&user_funcs, NtUserSetCallbacks );
 
     dpiaware_init();
+    winproc_init();
     register_desktop_class();
 
     /* Initialize system colors and metrics */

dlls/user32/user_private.h

@@ -158,6 +158,7 @@ extern INT_PTR WINPROC_CallDlgProcA( DLGPROC func, HWND hwnd, UINT msg, WPARAM w
 extern INT_PTR WINPROC_CallDlgProcW( DLGPROC func, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam ) DECLSPEC_HIDDEN;
 extern BOOL WINPROC_call_window( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
                                  LRESULT *result, BOOL unicode, enum wm_char_mapping mapping ) DECLSPEC_HIDDEN;
+extern void winproc_init(void) DECLSPEC_HIDDEN;
 
 extern const WCHAR *CLASS_GetVersionedName(const WCHAR *classname, UINT *basename_offset,
         WCHAR *combined, BOOL register_class) DECLSPEC_HIDDEN;

dlls/user32/winproc.c

@@ -35,62 +35,10 @@
 
 WINE_DECLARE_DEBUG_CHANNEL(msg);
 WINE_DECLARE_DEBUG_CHANNEL(relay);
-WINE_DEFAULT_DEBUG_CHANNEL(win);
 
-typedef struct tagWINDOWPROC
-{
-    WNDPROC        procA;    /* ANSI window proc */
-    WNDPROC        procW;    /* Unicode window proc */
-} WINDOWPROC;
-
-#define MAX_WINPROCS  4096
 #define MAX_WINPROC_RECURSION  64
 #define WINPROC_PROC16  ((WINDOWPROC *)1)  /* placeholder for 16-bit window procs */
 
-static LRESULT WINAPI ButtonWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI ButtonWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI ComboWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI ComboWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-LRESULT WINAPI EditWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI EditWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI ListBoxWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI ListBoxWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI MDIClientWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI ScrollBarWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI ScrollBarWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI StaticWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-static LRESULT WINAPI StaticWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
-
-static WINDOWPROC winproc_array[MAX_WINPROCS] =
-{
-    { ButtonWndProcA, ButtonWndProcW },        /* WINPROC_BUTTON */
-    { ComboWndProcA, ComboWndProcW },          /* WINPROC_COMBO */
-    { DefWindowProcA, DefWindowProcW },        /* WINPROC_DEFWND */
-    { DefDlgProcA, DefDlgProcW },              /* WINPROC_DIALOG */
-    { EditWndProcA, EditWndProcW },            /* WINPROC_EDIT */
-    { ListBoxWndProcA, ListBoxWndProcW },      /* WINPROC_LISTBOX */
-    { MDIClientWndProcA, MDIClientWndProcW },  /* WINPROC_MDICLIENT */
-    { ScrollBarWndProcA, ScrollBarWndProcW },  /* WINPROC_SCROLLBAR */
-    { StaticWndProcA, StaticWndProcW },        /* WINPROC_STATIC */
-    { ImeWndProcA, ImeWndProcW },              /* WINPROC_IME */
-    { NULL, DesktopWndProc },                  /* WINPROC_DESKTOP */
-    { NULL, IconTitleWndProc },                /* WINPROC_ICONTITLE */
-    { NULL, PopupMenuWndProc },                /* WINPROC_MENU */
-    { NULL, MessageWndProc },                  /* WINPROC_MESSAGE */
-};
-
-static UINT winproc_used = NB_BUILTIN_WINPROCS;
-
-static CRITICAL_SECTION winproc_cs;
-static CRITICAL_SECTION_DEBUG critsect_debug =
-{
-    0, 0, &winproc_cs,
-    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
-      0, 0, { (DWORD_PTR)(__FILE__ ": winproc_cs") }
-};
-static CRITICAL_SECTION winproc_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
-
 static inline void *get_buffer( void *static_buffer, size_t size, size_t need )
 {
     if (size >= need) return static_buffer;
@@ -102,73 +50,11 @@ static inline void free_buffer( void *static_buffer, void *buffer )
     if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
 }
 
-/* find an existing winproc for a given function and type */
-/* FIXME: probably should do something more clever than a linear search */
-static inline WINDOWPROC *find_winproc( WNDPROC func, BOOL unicode )
-{
-    unsigned int i;
-
-    for (i = 0; i < NB_BUILTIN_AW_WINPROCS; i++)
-    {
-        /* match either proc, some apps confuse A and W */
-        if (winproc_array[i].procA != func && winproc_array[i].procW != func) continue;
-        return &winproc_array[i];
-    }
-    for (i = NB_BUILTIN_AW_WINPROCS; i < winproc_used; i++)
-    {
-        if (!unicode && winproc_array[i].procA != func) continue;
-        if (unicode && winproc_array[i].procW != func) continue;
-        return &winproc_array[i];
-    }
-    return NULL;
-}
-
 /* return the window proc for a given handle, or NULL for an invalid handle,
  * or WINPROC_PROC16 for a handle to a 16-bit proc. */
 static inline WINDOWPROC *handle_to_proc( WNDPROC handle )
 {
-    UINT index = LOWORD(handle);
-    if ((ULONG_PTR)handle >> 16 != WINPROC_HANDLE) return NULL;
-    if (index >= MAX_WINPROCS) return WINPROC_PROC16;
-    if (index >= winproc_used) return NULL;
-    return &winproc_array[index];
-}
-
-/* create a handle for a given window proc */
-static inline WNDPROC proc_to_handle( WINDOWPROC *proc )
-{
-    return (WNDPROC)(ULONG_PTR)((proc - winproc_array) | (WINPROC_HANDLE << 16));
-}
-
-/* allocate and initialize a new winproc */
-static inline WINDOWPROC *alloc_winproc( WNDPROC func, BOOL unicode )
-{
-    WINDOWPROC *proc;
-
-    /* check if the function is already a win proc */
-    if (!func) return NULL;
-    if ((proc = handle_to_proc( func ))) return proc;
-
-    EnterCriticalSection( &winproc_cs );
-
-    /* check if we already have a winproc for that function */
-    if (!(proc = find_winproc( func, unicode )))
-    {
-        if (winproc_used < MAX_WINPROCS)
-        {
-            proc = &winproc_array[winproc_used++];
-            if (unicode) proc->procW = func;
-            else proc->procA = func;
-            TRACE( "allocated %p for %c %p (%d/%d used)\n",
-                   proc_to_handle(proc), unicode ? 'W' : 'A', func,
-                   winproc_used, MAX_WINPROCS );
-        }
-        else WARN( "too many winprocs, cannot allocate one for %p\n", func );
-    }
-    else TRACE( "reusing %p for %p\n", proc_to_handle(proc), func );
-
-    LeaveCriticalSection( &winproc_cs );
-    return proc;
+    return (WINDOWPROC *)NtUserCallOneParam( HandleToUlong(handle), NtUserGetWinProcPtr );
 }
 
 #ifdef __i386__
@@ -309,11 +195,7 @@ WNDPROC WINPROC_GetProc( WNDPROC proc, BOOL unicode )
  */
 WNDPROC WINPROC_AllocProc( WNDPROC func, BOOL unicode )
 {
-    WINDOWPROC *proc;
-
-    if (!(proc = alloc_winproc( func, unicode ))) return func;
-    if (proc == WINPROC_PROC16) return func;
-    return proc_to_handle( proc );
+    return (WNDPROC)NtUserCallTwoParam( (UINT_PTR)func, !unicode, NtUserAllocWinProc );
 }
 
 
@@ -1209,3 +1091,40 @@ struct wow_handlers16 wow_handlers =
     NULL,  /* call_dialog_proc */
     NULL,  /* free_icon_param */
 };
+
+static const struct user_client_procs client_procsA =
+{
+    .pButtonWndProc = ButtonWndProcA,
+    .pComboWndProc = ComboWndProcA,
+    .pDefWindowProc = DefWindowProcA,
+    .pDefDlgProc = DefDlgProcA,
+    .pEditWndProc = EditWndProcA,
+    .pListBoxWndProc = ListBoxWndProcA,
+    .pMDIClientWndProc = MDIClientWndProcA,
+    .pScrollBarWndProc = ScrollBarWndProcA,
+    .pStaticWndProc = StaticWndProcA,
+    .pImeWndProc = ImeWndProcA,
+};
+
+static const struct user_client_procs client_procsW =
+{
+    .pButtonWndProc = ButtonWndProcW,
+    .pComboWndProc = ComboWndProcW,
+    .pDefWindowProc = DefWindowProcW,
+    .pDefDlgProc = DefDlgProcW,
+    .pEditWndProc = EditWndProcW,
+    .pListBoxWndProc = ListBoxWndProcW,
+    .pMDIClientWndProc = MDIClientWndProcW,
+    .pScrollBarWndProc = ScrollBarWndProcW,
+    .pStaticWndProc = StaticWndProcW,
+    .pImeWndProc = ImeWndProcW,
+    .pDesktopWndProc = DesktopWndProc,
+    .pIconTitleWndProc = IconTitleWndProc,
+    .pPopupMenuWndProc = PopupMenuWndProc,
+    .pMessageWndProc = MessageWndProc,
+};
+
+void winproc_init(void)
+{
+    NtUserInitializeClientPfnArrays( &client_procsA, &client_procsW, NULL, user32_module );
+}

dlls/win32u/Makefile.in

@@ -12,6 +12,7 @@ C_SRCS = \
 	bitblt.c \
 	bitmap.c \
 	brush.c \
+	class.c \
 	clipboard.c \
 	clipping.c \
 	cursoricon.c \

dlls/win32u/class.c

+/*
+ * Window classes functions
+ *
+ * Copyright 1993, 1996, 2003 Alexandre Julliard
+ * Copyright 1995 Martin von Loewis
+ * Copyright 1998 Juergen Schmied (jsch)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#if 0
+#pragma makedep unix
+#endif
+
+#include <pthread.h>
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#include "win32u_private.h"
+#include "ntuser_private.h"
+#include "wine/debug.h"
+
+WINE_DECLARE_DEBUG_CHANNEL(win);
+
+#define MAX_WINPROCS  4096
+#define WINPROC_PROC16  ((WINDOWPROC *)1)  /* placeholder for 16-bit window procs */
+
+static WINDOWPROC winproc_array[MAX_WINPROCS];
+static UINT winproc_used = NB_BUILTIN_WINPROCS;
+static pthread_mutex_t winproc_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/* find an existing winproc for a given function and type */
+/* FIXME: probably should do something more clever than a linear search */
+static WINDOWPROC *find_winproc( WNDPROC func, BOOL ansi )
+{
+    unsigned int i;
+
+    for (i = 0; i < NB_BUILTIN_AW_WINPROCS; i++)
+    {
+        /* match either proc, some apps confuse A and W */
+        if (winproc_array[i].procA != func && winproc_array[i].procW != func) continue;
+        return &winproc_array[i];
+    }
+    for (i = NB_BUILTIN_AW_WINPROCS; i < winproc_used; i++)
+    {
+        if (ansi && winproc_array[i].procA != func) continue;
+        if (!ansi && winproc_array[i].procW != func) continue;
+        return &winproc_array[i];
+    }
+    return NULL;
+}
+
+/* return the window proc for a given handle, or NULL for an invalid handle,
+ * or WINPROC_PROC16 for a handle to a 16-bit proc. */
+WINDOWPROC *get_winproc_ptr( WNDPROC handle )
+{
+    UINT index = LOWORD(handle);
+    if ((ULONG_PTR)handle >> 16 != WINPROC_HANDLE) return NULL;
+    if (index >= MAX_WINPROCS) return WINPROC_PROC16;
+    if (index >= winproc_used) return NULL;
+    return &winproc_array[index];
+}
+
+/* create a handle for a given window proc */
+static inline WNDPROC proc_to_handle( WINDOWPROC *proc )
+{
+    return (WNDPROC)(ULONG_PTR)((proc - winproc_array) | (WINPROC_HANDLE << 16));
+}
+
+/* allocate and initialize a new winproc */
+static inline WINDOWPROC *alloc_winproc_ptr( WNDPROC func, BOOL ansi )
+{
+    WINDOWPROC *proc;
+
+    /* check if the function is already a win proc */
+    if (!func) return NULL;
+    if ((proc = get_winproc_ptr( func ))) return proc;
+
+    pthread_mutex_lock( &winproc_lock );
+
+    /* check if we already have a winproc for that function */
+    if (!(proc = find_winproc( func, ansi )))
+    {
+        if (winproc_used < MAX_WINPROCS)
+        {
+            proc = &winproc_array[winproc_used++];
+            if (ansi) proc->procA = func;
+            else proc->procW = func;
+            TRACE_(win)( "allocated %p for %c %p (%d/%d used)\n",
+                         proc_to_handle(proc), ansi ? 'A' : 'W', func,
+                         winproc_used, MAX_WINPROCS );
+        }
+        else WARN_(win)( "too many winprocs, cannot allocate one for %p\n", func );
+    }
+    else TRACE_(win)( "reusing %p for %p\n", proc_to_handle(proc), func );
+
+    pthread_mutex_unlock( &winproc_lock );
+    return proc;
+}
+
+/**********************************************************************
+ *	     alloc_winproc
+ *
+ * Allocate a window procedure for a window or class.
+ *
+ * Note that allocated winprocs are never freed; the idea is that even if an app creates a
+ * lot of windows, it will usually only have a limited number of window procedures, so the
+ * array won't grow too large, and this way we avoid the need to track allocations per window.
+ */
+WNDPROC alloc_winproc( WNDPROC func, BOOL ansi )
+{
+    WINDOWPROC *proc;
+
+    if (!(proc = alloc_winproc_ptr( func, ansi ))) return func;
+    if (proc == WINPROC_PROC16) return func;
+    return proc_to_handle( proc );
+}
+
+/***********************************************************************
+ *	     NtUserInitializeClientPfnArrays   (win32u.@)
+ */
+NTSTATUS WINAPI NtUserInitializeClientPfnArrays( const struct user_client_procs *client_procsA,
+                                                 const struct user_client_procs *client_procsW,
+                                                 const void *client_workers, HINSTANCE user_module )
+{
+    winproc_array[WINPROC_BUTTON].procA = client_procsA->pButtonWndProc;
+    winproc_array[WINPROC_BUTTON].procW = client_procsW->pButtonWndProc;
+    winproc_array[WINPROC_COMBO].procA = client_procsA->pComboWndProc;
+    winproc_array[WINPROC_COMBO].procW = client_procsW->pComboWndProc;
+    winproc_array[WINPROC_DEFWND].procA = client_procsA->pDefWindowProc;
+    winproc_array[WINPROC_DEFWND].procW = client_procsW->pDefWindowProc;
+    winproc_array[WINPROC_DIALOG].procA = client_procsA->pDefDlgProc;
+    winproc_array[WINPROC_DIALOG].procW = client_procsW->pDefDlgProc;
+    winproc_array[WINPROC_EDIT].procA = client_procsA->pEditWndProc;
+    winproc_array[WINPROC_EDIT].procW = client_procsW->pEditWndProc;
+    winproc_array[WINPROC_LISTBOX].procA = client_procsA->pListBoxWndProc;
+    winproc_array[WINPROC_LISTBOX].procW = client_procsW->pListBoxWndProc;
+    winproc_array[WINPROC_MDICLIENT].procA = client_procsA->pMDIClientWndProc;
+    winproc_array[WINPROC_MDICLIENT].procW = client_procsW->pMDIClientWndProc;
+    winproc_array[WINPROC_SCROLLBAR].procA = client_procsA->pScrollBarWndProc;
+    winproc_array[WINPROC_SCROLLBAR].procW = client_procsW->pScrollBarWndProc;
+    winproc_array[WINPROC_STATIC].procA = client_procsA->pStaticWndProc;
+    winproc_array[WINPROC_STATIC].procW = client_procsW->pStaticWndProc;
+    winproc_array[WINPROC_IME].procA = client_procsA->pImeWndProc;
+    winproc_array[WINPROC_IME].procW = client_procsW->pImeWndProc;
+    winproc_array[WINPROC_DESKTOP].procA = client_procsA->pDesktopWndProc;
+    winproc_array[WINPROC_DESKTOP].procW = client_procsW->pDesktopWndProc;
+    winproc_array[WINPROC_ICONTITLE].procA = client_procsA->pIconTitleWndProc;
+    winproc_array[WINPROC_ICONTITLE].procW = client_procsW->pIconTitleWndProc;
+    winproc_array[WINPROC_MENU].procA = client_procsA->pPopupMenuWndProc;
+    winproc_array[WINPROC_MENU].procW = client_procsW->pPopupMenuWndProc;
+    winproc_array[WINPROC_MESSAGE].procA = client_procsA->pMessageWndProc;
+    winproc_array[WINPROC_MESSAGE].procW = client_procsW->pMessageWndProc;
+
+    return STATUS_SUCCESS;
+}

dlls/win32u/ntuser_private.h

@@ -135,6 +135,42 @@ struct hook_extra_info
     LPARAM lparam;
 };
 
+enum builtin_winprocs
+{
+    /* dual A/W procs */
+    WINPROC_BUTTON = 0,
+    WINPROC_COMBO,
+    WINPROC_DEFWND,
+    WINPROC_DIALOG,
+    WINPROC_EDIT,
+    WINPROC_LISTBOX,
+    WINPROC_MDICLIENT,
+    WINPROC_SCROLLBAR,
+    WINPROC_STATIC,
+    WINPROC_IME,
+    /* unicode-only procs */
+    WINPROC_DESKTOP,
+    WINPROC_ICONTITLE,
+    WINPROC_MENU,
+    WINPROC_MESSAGE,
+    NB_BUILTIN_WINPROCS,
+    NB_BUILTIN_AW_WINPROCS = WINPROC_DESKTOP
+};
+
+/* FIXME: make it private to class.c */
+typedef struct tagWINDOWPROC
+{
+    WNDPROC        procA;    /* ANSI window proc */
+    WNDPROC        procW;    /* Unicode window proc */
+} WINDOWPROC;
+
+#define WINPROC_HANDLE (~0u >> 16)
+#define BUILTIN_WINPROC(index) ((WNDPROC)(ULONG_PTR)((index) | (WINPROC_HANDLE << 16)))
+
+/* class.c */
+WNDPROC alloc_winproc( WNDPROC func, BOOL ansi ) DECLSPEC_HIDDEN;
+WINDOWPROC *get_winproc_ptr( WNDPROC handle ) DECLSPEC_HIDDEN;
+
 /* cursoricon.c */
 HICON alloc_cursoricon_handle( BOOL is_icon ) DECLSPEC_HIDDEN;
 

dlls/win32u/syscall.c

@@ -136,6 +136,7 @@ static void * const syscalls[] =
     NtUserGetProp,
     NtUserGetSystemDpiForProcess,
     NtUserGetThreadDesktop,
+    NtUserInitializeClientPfnArrays,
     NtUserNotifyWinEvent,
     NtUserOpenDesktop,
     NtUserOpenInputDesktop,

dlls/win32u/sysparams.c

@@ -4594,6 +4594,8 @@ ULONG_PTR WINAPI NtUserCallOneParam( ULONG_PTR arg, ULONG code )
         return 0;
     case NtUserGetDeskPattern:
         return get_entry( &entry_DESKPATTERN, 256, (WCHAR *)arg );
+    case NtUserGetWinProcPtr:
+        return (UINT_PTR)get_winproc_ptr( UlongToHandle(arg) );
     case NtUserHandleInternalMessage:
         {
             MSG *msg = (MSG *)arg;
@@ -4640,6 +4642,8 @@ ULONG_PTR WINAPI NtUserCallTwoParam( ULONG_PTR arg1, ULONG_PTR arg2, ULONG code
     /* temporary exports */
     case NtUserAllocHandle:
         return HandleToUlong( alloc_user_handle( (struct user_object *)arg1, arg2 ));
+    case NtUserAllocWinProc:
+        return (UINT_PTR)alloc_winproc( (WNDPROC)arg1, arg2 );
     case NtUserFreeHandle:
         return (UINT_PTR)free_user_handle( UlongToHandle(arg1), arg2 );
     case NtUserGetHandlePtr:

dlls/win32u/win32u.spec

@@ -1030,7 +1030,7 @@
 @ stub NtUserInheritWindowMonitor
 @ stub NtUserInitTask
 @ stub NtUserInitialize
-@ stub NtUserInitializeClientPfnArrays
+@ stdcall -syscall NtUserInitializeClientPfnArrays(ptr ptr ptr ptr)
 @ stub NtUserInitializeGenericHidInjection
 @ stub NtUserInitializeInputDeviceInjection
 @ stub NtUserInitializePointerDeviceInjection

dlls/wow64win/syscall.h

@@ -123,6 +123,7 @@
     SYSCALL_ENTRY( NtUserGetProp ) \
     SYSCALL_ENTRY( NtUserGetSystemDpiForProcess ) \
     SYSCALL_ENTRY( NtUserGetThreadDesktop ) \
+    SYSCALL_ENTRY( NtUserInitializeClientPfnArrays ) \
     SYSCALL_ENTRY( NtUserNotifyWinEvent ) \
     SYSCALL_ENTRY( NtUserOpenDesktop ) \
     SYSCALL_ENTRY( NtUserOpenInputDesktop ) \

dlls/wow64win/user.c

@@ -26,7 +26,15 @@
 #include "winbase.h"
 #include "ntuser.h"
 #include "wow64win_private.h"
+#include "wine/debug.h"
 
+WINE_DEFAULT_DEBUG_CHANNEL(wow);
+
+NTSTATUS WINAPI wow64_NtUserInitializeClientPfnArrays( UINT *args )
+{
+    FIXME( "\n" );
+    return STATUS_NOT_SUPPORTED;
+}
 
 NTSTATUS WINAPI wow64_NtUserCreateWindowStation( UINT *args )
 {

include/ntuser.h

@@ -110,6 +110,7 @@ enum
     NtUserCallHooks,
     NtUserFlushWindowSurfaces,
     NtUserGetDeskPattern,
+    NtUserGetWinProcPtr,
     NtUserHandleInternalMessage,
     NtUserIncrementKeyStateCounter,
     NtUserLock,
@@ -128,6 +129,7 @@ enum
     NtUserUnhookWindowsHook,
     /* temporary exports */
     NtUserAllocHandle,
+    NtUserAllocWinProc,
     NtUserFreeHandle,
     NtUserGetHandlePtr,
     NtUserRegisterWindowSurface,
@@ -157,6 +159,25 @@ enum
 #define NTUSER_OBJ_ACCEL    0x08
 #define NTUSER_OBJ_HOOK     0x0f
 
+/* NtUserInitializeClientPfnArrays parameter, not compatible with Windows */
+struct user_client_procs
+{
+    WNDPROC pButtonWndProc;
+    WNDPROC pComboWndProc;
+    WNDPROC pDefWindowProc;
+    WNDPROC pDefDlgProc;
+    WNDPROC pEditWndProc;
+    WNDPROC pListBoxWndProc;
+    WNDPROC pMDIClientWndProc;
+    WNDPROC pScrollBarWndProc;
+    WNDPROC pStaticWndProc;
+    WNDPROC pImeWndProc;
+    WNDPROC pDesktopWndProc;
+    WNDPROC pIconTitleWndProc;
+    WNDPROC pPopupMenuWndProc;
+    WNDPROC pMessageWndProc;
+};
+
 /* NtUserSetCursorIconData parameter, not compatible with Windows */
 struct cursoricon_frame
 {
@@ -272,6 +293,9 @@ DWORD   WINAPI NtUserGetQueueStatus( UINT flags );
 ULONG   WINAPI NtUserGetSystemDpiForProcess( HANDLE process );
 HDESK   WINAPI NtUserGetThreadDesktop( DWORD thread );
 BOOL    WINAPI NtUserGetUpdatedClipboardFormats( UINT *formats, UINT size, UINT *out_size );
+NTSTATUS WINAPI NtUserInitializeClientPfnArrays( const struct user_client_procs *client_procsA,
+                                                 const struct user_client_procs *client_procsW,
+                                                 const void *client_workers, HINSTANCE user_module );
 BOOL    WINAPI NtUserIsClipboardFormatAvailable( UINT format );
 UINT    WINAPI NtUserMapVirtualKeyEx( UINT code, UINT type, HKL layout );
 void    WINAPI NtUserNotifyWinEvent( DWORD event, HWND hwnd, LONG object_id, LONG child_id );