server: Don't pass a thread id to send_hardware_message, determine it from the window.

diff --git a/dlls/winex11.drv/keyboard.c b/dlls/winex11.drv/keyboard.c
index d8ab4d2de309dc01613875a756f47a3e3040974e..8a8f482da5ad318acba780b9d3da8ecfd04c82a1 100644 (file)
--- a/dlls/winex11.drv/keyboard.c
+++ b/dlls/winex11.drv/keyboard.c
@@ -1267,7 +1267,6 @@ void X11DRV_send_keyboard_input( HWND hwnd, WORD wVk, WORD wScan, DWORD event_fl
 
     SERVER_START_REQ( send_hardware_message )
     {
-        req->id       = (injected_flags & LLKHF_INJECTED) ? 0 : GetCurrentThreadId();
         req->win      = wine_server_user_handle( hwnd );
         req->msg      = message;
         req->wparam   = wVk;

diff --git a/dlls/winex11.drv/mouse.c b/dlls/winex11.drv/mouse.c
index 2950246843bee5f5684bd1265a8c8d60a49ba12e..811695a5da975bc322bf3d28dd608bc0d1219d0f 100644 (file)
--- a/dlls/winex11.drv/mouse.c
+++ b/dlls/winex11.drv/mouse.c
@@ -306,7 +306,6 @@ static void queue_raw_mouse_message( UINT message, HWND hwnd, DWORD x, DWORD y,
 
     SERVER_START_REQ( send_hardware_message )
     {
-        req->id       = (injected_flags & LLMHF_INJECTED) ? 0 : GetCurrentThreadId();
         req->win      = wine_server_user_handle( hwnd );
         req->msg      = message;
         req->wparam   = MAKEWPARAM( 0, data );

diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h
index 66f1cdb71302f1ffa8d7d9c82b908d083a989200..4a25433735a51319b988cada32357abf027ec87a 100644 (file)
--- a/include/wine/server_protocol.h
+++ b/include/wine/server_protocol.h
@@ -2761,22 +2761,18 @@ enum message_type
 struct send_hardware_message_request
 {
     struct request_header __header;
-    thread_id_t     id;
     user_handle_t   win;
     unsigned int    msg;
+    unsigned int    time;
     lparam_t        wparam;
     lparam_t        lparam;
     lparam_t        info;
     int             x;
     int             y;
-    unsigned int    time;
-    char __pad_60[4];
 };
 struct send_hardware_message_reply
 {
     struct reply_header __header;
-    user_handle_t   cursor;
-    int             count;
 };
 
 
@@ -5533,6 +5529,6 @@ union generic_reply
     struct set_cursor_reply set_cursor_reply;
 };
 
-#define SERVER_PROTOCOL_VERSION 414
+#define SERVER_PROTOCOL_VERSION 415
 
 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */

diff --git a/server/protocol.def b/server/protocol.def
index e38857d58af3f7dd05b47d66f11edcbbfeb06bda..c1e4fdbef431b9a6555b2c8e37eb7d3161ae9219 100644 (file)
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -2001,18 +2001,14 @@ enum message_type
 
 /* Send a hardware message to a thread queue */
 @REQ(send_hardware_message)
-    thread_id_t     id;        /* thread id */
     user_handle_t   win;       /* window handle */
     unsigned int    msg;       /* message code */
+    unsigned int    time;      /* message time */
     lparam_t        wparam;    /* parameters */
     lparam_t        lparam;    /* parameters */
     lparam_t        info;      /* extra info */
     int             x;         /* x position */
     int             y;         /* y position */
-    unsigned int    time;      /* message time */
-@REPLY
-    user_handle_t   cursor;    /* current cursor for the target thread input */
-    int             count;     /* current cursor count */
 @END
 
 

diff --git a/server/queue.c b/server/queue.c
index 3526790eb85e32ba76c79b9b4521ceddb6151a5e..58be426cbec82b81490429b615100907702d810b 100644 (file)
--- a/server/queue.c
+++ b/server/queue.c
@@ -1237,8 +1237,8 @@ static void release_hardware_message( struct msg_queue *queue, unsigned int hw_i
 }
 
 /* find the window that should receive a given hardware message */
-static user_handle_t find_hardware_message_window( struct thread_input *input, struct message *msg,
-                                                   unsigned int *msg_code )
+static user_handle_t find_hardware_message_window( struct desktop *desktop, struct thread_input *input,
+                                                   struct message *msg, unsigned int *msg_code )
 {
     struct hardware_msg_data *data = msg->data;
     user_handle_t win = 0;
@@ -1257,9 +1257,7 @@ static user_handle_t find_hardware_message_window( struct thread_input *input, s
         if (!input || !(win = input->capture))
         {
             if (!(win = msg->win) || !is_window_visible( win ) || is_window_transparent( win ))
-            {
-                if (input) win = window_from_point( input->desktop, data->x, data->y );
-            }
+                win = window_from_point( desktop, data->x, data->y );
         }
     }
     return win;
@@ -1273,11 +1271,11 @@ static void set_cursor_pos( struct desktop *desktop, int x, int y )
 }
 
 /* queue a hardware message into a given thread input */
-static void queue_hardware_message( struct desktop *desktop, struct thread_input *input,
-                                    struct message *msg )
+static void queue_hardware_message( struct desktop *desktop, struct message *msg )
 {
     user_handle_t win;
     struct thread *thread;
+    struct thread_input *input;
     unsigned int msg_code;
     struct hardware_msg_data *data = msg->data;
 
@@ -1298,7 +1296,14 @@ static void queue_hardware_message( struct desktop *desktop, struct thread_input
     data->x = desktop->cursor_x;
     data->y = desktop->cursor_y;
 
-    win = find_hardware_message_window( input, msg, &msg_code );
+    if (msg->win && (thread = get_window_thread( msg->win )))
+    {
+        input = thread->queue->input;
+        release_object( thread );
+    }
+    else input = desktop->foreground_input;
+
+    win = find_hardware_message_window( desktop, input, msg, &msg_code );
     if (!win || !(thread = get_window_thread(win)))
     {
         if (input) update_input_key_state( input->desktop, input->keystate, msg );
@@ -1387,7 +1392,7 @@ static int get_hardware_message( struct thread *thread, unsigned int hw_id, user
         struct hardware_msg_data *data = msg->data;
 
         ptr = list_next( &input->msg_list, ptr );
-        win = find_hardware_message_window( input, msg, &msg_code );
+        win = find_hardware_message_window( input->desktop, input, msg, &msg_code );
         if (!win || !(win_thread = get_window_thread( win )))
         {
             /* no window at all, remove it */
@@ -1732,31 +1737,17 @@ DECL_HANDLER(send_hardware_message)
 {
     struct message *msg;
     struct thread *thread = NULL;
-    struct desktop *desktop = NULL;
+    struct desktop *desktop;
     struct hardware_msg_data *data;
-    struct thread_input *input;
 
-    if (req->id)
-    {
-        if (!(thread = get_thread_from_id( req->id ))) return;
-        if (!thread->queue)
-        {
-            set_error( STATUS_INVALID_PARAMETER );
-            release_object( thread );
-            return;
-        }
-        input = thread->queue->input;
-        desktop = (struct desktop *)grab_object( input->desktop );
-        reply->cursor = input->cursor;
-        reply->count  = input->cursor_count;
-    }
-    else
+    if (req->win)
     {
-        if (!(desktop = get_thread_desktop( current, 0 ))) return;
-        input = desktop->foreground_input;
+        if (!(thread = get_window_thread( req->win ))) return;
+        desktop = (struct desktop *)grab_object( thread->queue->input->desktop );
     }
+    else if (!(desktop = get_thread_desktop( current, 0 ))) return;
 
-    if (!req->msg || !(data = mem_alloc( sizeof(*data) ))) goto done;
+    if (!(data = mem_alloc( sizeof(*data) ))) goto done;
 
     memset( data, 0, sizeof(*data) );
     data->x    = req->x;
@@ -1774,7 +1765,7 @@ DECL_HANDLER(send_hardware_message)
         msg->result    = NULL;
         msg->data      = data;
         msg->data_size = sizeof(*data);
-        queue_hardware_message( desktop, input, msg );
+        queue_hardware_message( desktop, msg );
     }
     else free( data );
 

diff --git a/server/request.h b/server/request.h
index 67ec84434ad38a934c3eb1aa32ce3669d1ae00ce..d757987eee9447c771cb18965be293204ae1368f 100644 (file)
--- a/server/request.h
+++ b/server/request.h
@@ -1377,19 +1377,15 @@ C_ASSERT( FIELD_OFFSET(struct send_message_request, timeout) == 48 );
 C_ASSERT( sizeof(struct send_message_request) == 56 );
 C_ASSERT( FIELD_OFFSET(struct post_quit_message_request, exit_code) == 12 );
 C_ASSERT( sizeof(struct post_quit_message_request) == 16 );
-C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, id) == 12 );
-C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, win) == 16 );
-C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, msg) == 20 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, win) == 12 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, msg) == 16 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, time) == 20 );
 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, wparam) == 24 );
 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, lparam) == 32 );
 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, info) == 40 );
 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, x) == 48 );
 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, y) == 52 );
-C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, time) == 56 );
-C_ASSERT( sizeof(struct send_hardware_message_request) == 64 );
-C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, cursor) == 8 );
-C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, count) == 12 );
-C_ASSERT( sizeof(struct send_hardware_message_reply) == 16 );
+C_ASSERT( sizeof(struct send_hardware_message_request) == 56 );
 C_ASSERT( FIELD_OFFSET(struct get_message_request, flags) == 12 );
 C_ASSERT( FIELD_OFFSET(struct get_message_request, get_win) == 16 );
 C_ASSERT( FIELD_OFFSET(struct get_message_request, get_first) == 20 );

diff --git a/server/trace.c b/server/trace.c
index 7ea8ceeb071028a17de78f20335951b02be1c2e3..0539fccd1919319e9d979dfe0e5da59d8a5f689c 100644 (file)
--- a/server/trace.c
+++ b/server/trace.c
@@ -2464,21 +2464,14 @@ static void dump_post_quit_message_request( const struct post_quit_message_reque
 
 static void dump_send_hardware_message_request( const struct send_hardware_message_request *req )
 {
-    fprintf( stderr, " id=%04x", req->id );
-    fprintf( stderr, ", win=%08x", req->win );
+    fprintf( stderr, " win=%08x", req->win );
     fprintf( stderr, ", msg=%08x", req->msg );
+    fprintf( stderr, ", time=%08x", req->time );
     dump_uint64( ", wparam=", &req->wparam );
     dump_uint64( ", lparam=", &req->lparam );
     dump_uint64( ", info=", &req->info );
     fprintf( stderr, ", x=%d", req->x );
     fprintf( stderr, ", y=%d", req->y );
-    fprintf( stderr, ", time=%08x", req->time );
-}
-
-static void dump_send_hardware_message_reply( const struct send_hardware_message_reply *req )
-{
-    fprintf( stderr, " cursor=%08x", req->cursor );
-    fprintf( stderr, ", count=%d", req->count );
 }
 
 static void dump_get_message_request( const struct get_message_request *req )
@@ -4257,7 +4250,7 @@ static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
     (dump_func)dump_get_process_idle_event_reply,
     NULL,
     NULL,
-    (dump_func)dump_send_hardware_message_reply,
+    NULL,
     (dump_func)dump_get_message_reply,
     NULL,
     NULL,