d3dx9_36/tests: Add a trailing '\n' to an ok() call.
[wine] / server / queue.c
1 /*
2  * Server-side message queues
3  *
4  * Copyright (C) 2000 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28
29 #include "ntstatus.h"
30 #define WIN32_NO_STATUS
31 #include "windef.h"
32 #include "winbase.h"
33 #include "wingdi.h"
34 #include "winuser.h"
35 #include "winternl.h"
36
37 #include "handle.h"
38 #include "file.h"
39 #include "thread.h"
40 #include "process.h"
41 #include "request.h"
42 #include "user.h"
43
44 #define WM_NCMOUSEFIRST WM_NCMOUSEMOVE
45 #define WM_NCMOUSELAST  (WM_NCMOUSEFIRST+(WM_MOUSELAST-WM_MOUSEFIRST))
46
47 enum message_kind { SEND_MESSAGE, POST_MESSAGE };
48 #define NB_MSG_KINDS (POST_MESSAGE+1)
49
50
51 struct message_result
52 {
53     struct list            sender_entry;  /* entry in sender list */
54     struct message        *msg;           /* message the result is for */
55     struct message_result *recv_next;     /* next in receiver list */
56     struct msg_queue      *sender;        /* sender queue */
57     struct msg_queue      *receiver;      /* receiver queue */
58     int                    replied;       /* has it been replied to? */
59     unsigned int           error;         /* error code to pass back to sender */
60     lparam_t               result;        /* reply result */
61     struct message        *hardware_msg;  /* hardware message if low-level hook result */
62     struct desktop        *desktop;       /* desktop for hardware message */
63     struct message        *callback_msg;  /* message to queue for callback */
64     void                  *data;          /* message reply data */
65     unsigned int           data_size;     /* size of message reply data */
66     struct timeout_user   *timeout;       /* result timeout */
67 };
68
69 struct message
70 {
71     struct list            entry;     /* entry in message list */
72     enum message_type      type;      /* message type */
73     user_handle_t          win;       /* window handle */
74     unsigned int           msg;       /* message code */
75     lparam_t               wparam;    /* parameters */
76     lparam_t               lparam;    /* parameters */
77     unsigned int           time;      /* message time */
78     void                  *data;      /* message data for sent messages */
79     unsigned int           data_size; /* size of message data */
80     unsigned int           unique_id; /* unique id for nested hw message waits */
81     struct message_result *result;    /* result in sender queue */
82 };
83
84 struct timer
85 {
86     struct list     entry;     /* entry in timer list */
87     timeout_t       when;      /* next expiration */
88     unsigned int    rate;      /* timer rate in ms */
89     user_handle_t   win;       /* window handle */
90     unsigned int    msg;       /* message to post */
91     lparam_t        id;        /* timer id */
92     lparam_t        lparam;    /* lparam for message */
93 };
94
95 struct thread_input
96 {
97     struct object          obj;           /* object header */
98     struct desktop        *desktop;       /* desktop that this thread input belongs to */
99     user_handle_t          focus;         /* focus window */
100     user_handle_t          capture;       /* capture window */
101     user_handle_t          active;        /* active window */
102     user_handle_t          menu_owner;    /* current menu owner window */
103     user_handle_t          move_size;     /* current moving/resizing window */
104     user_handle_t          caret;         /* caret window */
105     rectangle_t            caret_rect;    /* caret rectangle */
106     int                    caret_hide;    /* caret hide count */
107     int                    caret_state;   /* caret on/off state */
108     user_handle_t          cursor;        /* current cursor */
109     int                    cursor_count;  /* cursor show count */
110     struct list            msg_list;      /* list of hardware messages */
111     unsigned char          keystate[256]; /* state of each key */
112 };
113
114 struct msg_queue
115 {
116     struct object          obj;             /* object header */
117     struct fd             *fd;              /* optional file descriptor to poll */
118     unsigned int           wake_bits;       /* wakeup bits */
119     unsigned int           wake_mask;       /* wakeup mask */
120     unsigned int           changed_bits;    /* changed wakeup bits */
121     unsigned int           changed_mask;    /* changed wakeup mask */
122     int                    paint_count;     /* pending paint messages count */
123     int                    hotkey_count;    /* pending hotkey messages count */
124     int                    quit_message;    /* is there a pending quit message? */
125     int                    exit_code;       /* exit code of pending quit message */
126     int                    cursor_count;    /* per-queue cursor show count */
127     struct list            msg_list[NB_MSG_KINDS];  /* lists of messages */
128     struct list            send_result;     /* stack of sent messages waiting for result */
129     struct list            callback_result; /* list of callback messages waiting for result */
130     struct message_result *recv_result;     /* stack of received messages waiting for result */
131     struct list            pending_timers;  /* list of pending timers */
132     struct list            expired_timers;  /* list of expired timers */
133     lparam_t               next_timer_id;   /* id for the next timer with a 0 window */
134     struct timeout_user   *timeout;         /* timeout for next timer to expire */
135     struct thread_input   *input;           /* thread input descriptor */
136     struct hook_table     *hooks;           /* hook table */
137     timeout_t              last_get_msg;    /* time of last get message call */
138 };
139
140 struct hotkey
141 {
142     struct list         entry;        /* entry in desktop hotkey list */
143     struct msg_queue   *queue;        /* queue owning this hotkey */
144     user_handle_t       win;          /* window handle */
145     int                 id;           /* hotkey id */
146     unsigned int        vkey;         /* virtual key code */
147     unsigned int        flags;        /* key modifiers */
148 };
149
150 static void msg_queue_dump( struct object *obj, int verbose );
151 static int msg_queue_add_queue( struct object *obj, struct wait_queue_entry *entry );
152 static void msg_queue_remove_queue( struct object *obj, struct wait_queue_entry *entry );
153 static int msg_queue_signaled( struct object *obj, struct thread *thread );
154 static int msg_queue_satisfied( struct object *obj, struct thread *thread );
155 static void msg_queue_destroy( struct object *obj );
156 static void msg_queue_poll_event( struct fd *fd, int event );
157 static void thread_input_dump( struct object *obj, int verbose );
158 static void thread_input_destroy( struct object *obj );
159 static void timer_callback( void *private );
160
161 static const struct object_ops msg_queue_ops =
162 {
163     sizeof(struct msg_queue),  /* size */
164     msg_queue_dump,            /* dump */
165     no_get_type,               /* get_type */
166     msg_queue_add_queue,       /* add_queue */
167     msg_queue_remove_queue,    /* remove_queue */
168     msg_queue_signaled,        /* signaled */
169     msg_queue_satisfied,       /* satisfied */
170     no_signal,                 /* signal */
171     no_get_fd,                 /* get_fd */
172     no_map_access,             /* map_access */
173     default_get_sd,            /* get_sd */
174     default_set_sd,            /* set_sd */
175     no_lookup_name,            /* lookup_name */
176     no_open_file,              /* open_file */
177     no_close_handle,           /* close_handle */
178     msg_queue_destroy          /* destroy */
179 };
180
181 static const struct fd_ops msg_queue_fd_ops =
182 {
183     NULL,                        /* get_poll_events */
184     msg_queue_poll_event,        /* poll_event */
185     NULL,                        /* flush */
186     NULL,                        /* get_fd_type */
187     NULL,                        /* ioctl */
188     NULL,                        /* queue_async */
189     NULL,                        /* reselect_async */
190     NULL                         /* cancel async */
191 };
192
193
194 static const struct object_ops thread_input_ops =
195 {
196     sizeof(struct thread_input),  /* size */
197     thread_input_dump,            /* dump */
198     no_get_type,                  /* get_type */
199     no_add_queue,                 /* add_queue */
200     NULL,                         /* remove_queue */
201     NULL,                         /* signaled */
202     NULL,                         /* satisfied */
203     no_signal,                    /* signal */
204     no_get_fd,                    /* get_fd */
205     no_map_access,                /* map_access */
206     default_get_sd,               /* get_sd */
207     default_set_sd,               /* set_sd */
208     no_lookup_name,               /* lookup_name */
209     no_open_file,                 /* open_file */
210     no_close_handle,              /* close_handle */
211     thread_input_destroy          /* destroy */
212 };
213
214 /* pointer to input structure of foreground thread */
215 static unsigned int last_input_time;
216
217 static void queue_hardware_message( struct desktop *desktop, struct message *msg, int always_queue );
218 static void free_message( struct message *msg );
219
220 /* set the caret window in a given thread input */
221 static void set_caret_window( struct thread_input *input, user_handle_t win )
222 {
223     if (!win || win != input->caret)
224     {
225         input->caret_rect.left   = 0;
226         input->caret_rect.top    = 0;
227         input->caret_rect.right  = 0;
228         input->caret_rect.bottom = 0;
229     }
230     input->caret             = win;
231     input->caret_hide        = 1;
232     input->caret_state       = 0;
233 }
234
235 /* create a thread input object */
236 static struct thread_input *create_thread_input( struct thread *thread )
237 {
238     struct thread_input *input;
239
240     if ((input = alloc_object( &thread_input_ops )))
241     {
242         input->focus        = 0;
243         input->capture      = 0;
244         input->active       = 0;
245         input->menu_owner   = 0;
246         input->move_size    = 0;
247         input->cursor       = 0;
248         input->cursor_count = 0;
249         list_init( &input->msg_list );
250         set_caret_window( input, 0 );
251         memset( input->keystate, 0, sizeof(input->keystate) );
252
253         if (!(input->desktop = get_thread_desktop( thread, 0 /* FIXME: access rights */ )))
254         {
255             release_object( input );
256             return NULL;
257         }
258     }
259     return input;
260 }
261
262 /* create a message queue object */
263 static struct msg_queue *create_msg_queue( struct thread *thread, struct thread_input *input )
264 {
265     struct thread_input *new_input = NULL;
266     struct msg_queue *queue;
267     int i;
268
269     if (!input)
270     {
271         if (!(new_input = create_thread_input( thread ))) return NULL;
272         input = new_input;
273     }
274
275     if ((queue = alloc_object( &msg_queue_ops )))
276     {
277         queue->fd              = NULL;
278         queue->wake_bits       = 0;
279         queue->wake_mask       = 0;
280         queue->changed_bits    = 0;
281         queue->changed_mask    = 0;
282         queue->paint_count     = 0;
283         queue->hotkey_count    = 0;
284         queue->quit_message    = 0;
285         queue->cursor_count    = 0;
286         queue->recv_result     = NULL;
287         queue->next_timer_id   = 0x7fff;
288         queue->timeout         = NULL;
289         queue->input           = (struct thread_input *)grab_object( input );
290         queue->hooks           = NULL;
291         queue->last_get_msg    = current_time;
292         list_init( &queue->send_result );
293         list_init( &queue->callback_result );
294         list_init( &queue->pending_timers );
295         list_init( &queue->expired_timers );
296         for (i = 0; i < NB_MSG_KINDS; i++) list_init( &queue->msg_list[i] );
297
298         thread->queue = queue;
299     }
300     if (new_input) release_object( new_input );
301     return queue;
302 }
303
304 /* free the message queue of a thread at thread exit */
305 void free_msg_queue( struct thread *thread )
306 {
307     remove_thread_hooks( thread );
308     if (!thread->queue) return;
309     release_object( thread->queue );
310     thread->queue = NULL;
311 }
312
313 /* change the thread input data of a given thread */
314 static int assign_thread_input( struct thread *thread, struct thread_input *new_input )
315 {
316     struct msg_queue *queue = thread->queue;
317
318     if (!queue)
319     {
320         thread->queue = create_msg_queue( thread, new_input );
321         return thread->queue != NULL;
322     }
323     if (queue->input)
324     {
325         queue->input->cursor_count -= queue->cursor_count;
326         release_object( queue->input );
327     }
328     queue->input = (struct thread_input *)grab_object( new_input );
329     new_input->cursor_count += queue->cursor_count;
330     return 1;
331 }
332
333 /* set the cursor position and queue the corresponding mouse message */
334 static void set_cursor_pos( struct desktop *desktop, int x, int y )
335 {
336     struct hardware_msg_data *msg_data;
337     struct message *msg;
338
339     if (!(msg = mem_alloc( sizeof(*msg) ))) return;
340     if (!(msg_data = mem_alloc( sizeof(*msg_data) )))
341     {
342         free( msg );
343         return;
344     }
345     memset( msg_data, 0, sizeof(*msg_data) );
346
347     msg->type      = MSG_HARDWARE;
348     msg->win       = 0;
349     msg->msg       = WM_MOUSEMOVE;
350     msg->wparam    = 0;
351     msg->lparam    = 0;
352     msg->time      = get_tick_count();
353     msg->result    = NULL;
354     msg->data      = msg_data;
355     msg->data_size = sizeof(*msg_data);
356     msg_data->x    = x;
357     msg_data->y    = y;
358     queue_hardware_message( desktop, msg, 1 );
359 }
360
361 /* set the cursor clip rectangle */
362 static void set_clip_rectangle( struct desktop *desktop, const rectangle_t *rect )
363 {
364     rectangle_t top_rect;
365     int x, y;
366
367     get_top_window_rectangle( desktop, &top_rect );
368     if (rect)
369     {
370         rectangle_t new_rect = *rect;
371         if (new_rect.left   < top_rect.left)   new_rect.left   = top_rect.left;
372         if (new_rect.right  > top_rect.right)  new_rect.right  = top_rect.right;
373         if (new_rect.top    < top_rect.top)    new_rect.top    = top_rect.top;
374         if (new_rect.bottom > top_rect.bottom) new_rect.bottom = top_rect.bottom;
375         if (new_rect.left > new_rect.right || new_rect.top > new_rect.bottom) new_rect = top_rect;
376         desktop->cursor.clip = new_rect;
377     }
378     else desktop->cursor.clip = top_rect;
379
380     if (desktop->cursor.clip_msg)
381         post_desktop_message( desktop, desktop->cursor.clip_msg, rect != NULL, 0 );
382
383     /* warp the mouse to be inside the clip rect */
384     x = min( max( desktop->cursor.x, desktop->cursor.clip.left ), desktop->cursor.clip.right-1 );
385     y = min( max( desktop->cursor.y, desktop->cursor.clip.top ), desktop->cursor.clip.bottom-1 );
386     if (x != desktop->cursor.x || y != desktop->cursor.y) set_cursor_pos( desktop, x, y );
387 }
388
389 /* change the foreground input and reset the cursor clip rect */
390 static void set_foreground_input( struct desktop *desktop, struct thread_input *input )
391 {
392     if (desktop->foreground_input == input) return;
393     set_clip_rectangle( desktop, NULL );
394     desktop->foreground_input = input;
395 }
396
397 /* get the hook table for a given thread */
398 struct hook_table *get_queue_hooks( struct thread *thread )
399 {
400     if (!thread->queue) return NULL;
401     return thread->queue->hooks;
402 }
403
404 /* set the hook table for a given thread, allocating the queue if needed */
405 void set_queue_hooks( struct thread *thread, struct hook_table *hooks )
406 {
407     struct msg_queue *queue = thread->queue;
408     if (!queue && !(queue = create_msg_queue( thread, NULL ))) return;
409     if (queue->hooks) release_object( queue->hooks );
410     queue->hooks = hooks;
411 }
412
413 /* check the queue status */
414 static inline int is_signaled( struct msg_queue *queue )
415 {
416     return ((queue->wake_bits & queue->wake_mask) || (queue->changed_bits & queue->changed_mask));
417 }
418
419 /* set some queue bits */
420 static inline void set_queue_bits( struct msg_queue *queue, unsigned int bits )
421 {
422     queue->wake_bits |= bits;
423     queue->changed_bits |= bits;
424     if (is_signaled( queue )) wake_up( &queue->obj, 0 );
425 }
426
427 /* clear some queue bits */
428 static inline void clear_queue_bits( struct msg_queue *queue, unsigned int bits )
429 {
430     queue->wake_bits &= ~bits;
431     queue->changed_bits &= ~bits;
432 }
433
434 /* check whether msg is a keyboard message */
435 static inline int is_keyboard_msg( struct message *msg )
436 {
437     return (msg->msg >= WM_KEYFIRST && msg->msg <= WM_KEYLAST);
438 }
439
440 /* check if message is matched by the filter */
441 static inline int check_msg_filter( unsigned int msg, unsigned int first, unsigned int last )
442 {
443     return (msg >= first && msg <= last);
444 }
445
446 /* check whether a message filter contains at least one potential hardware message */
447 static inline int filter_contains_hw_range( unsigned int first, unsigned int last )
448 {
449     /* hardware message ranges are (in numerical order):
450      *   WM_NCMOUSEFIRST .. WM_NCMOUSELAST
451      *   WM_KEYFIRST .. WM_KEYLAST
452      *   WM_MOUSEFIRST .. WM_MOUSELAST
453      */
454     if (last < WM_NCMOUSEFIRST) return 0;
455     if (first > WM_NCMOUSELAST && last < WM_KEYFIRST) return 0;
456     if (first > WM_KEYLAST && last < WM_MOUSEFIRST) return 0;
457     if (first > WM_MOUSELAST) return 0;
458     return 1;
459 }
460
461 /* get the QS_* bit corresponding to a given hardware message */
462 static inline int get_hardware_msg_bit( struct message *msg )
463 {
464     if (msg->msg == WM_MOUSEMOVE || msg->msg == WM_NCMOUSEMOVE) return QS_MOUSEMOVE;
465     if (is_keyboard_msg( msg )) return QS_KEY;
466     return QS_MOUSEBUTTON;
467 }
468
469 /* get the current thread queue, creating it if needed */
470 static inline struct msg_queue *get_current_queue(void)
471 {
472     struct msg_queue *queue = current->queue;
473     if (!queue) queue = create_msg_queue( current, NULL );
474     return queue;
475 }
476
477 /* get a (pseudo-)unique id to tag hardware messages */
478 static inline unsigned int get_unique_id(void)
479 {
480     static unsigned int id;
481     if (!++id) id = 1;  /* avoid an id of 0 */
482     return id;
483 }
484
485 /* try to merge a message with the last in the list; return 1 if successful */
486 static int merge_message( struct thread_input *input, const struct message *msg )
487 {
488     struct message *prev;
489     struct list *ptr;
490
491     if (msg->msg != WM_MOUSEMOVE) return 0;
492     if (!(ptr = list_tail( &input->msg_list ))) return 0;
493     prev = LIST_ENTRY( ptr, struct message, entry );
494     if (prev->result) return 0;
495     if (prev->win && msg->win && prev->win != msg->win) return 0;
496     if (prev->msg != msg->msg) return 0;
497     if (prev->type != msg->type) return 0;
498     /* now we can merge it */
499     prev->wparam  = msg->wparam;
500     prev->lparam  = msg->lparam;
501     prev->time    = msg->time;
502     if (msg->type == MSG_HARDWARE && prev->data && msg->data)
503     {
504         struct hardware_msg_data *prev_data = prev->data;
505         struct hardware_msg_data *msg_data = msg->data;
506         prev_data->x     = msg_data->x;
507         prev_data->y     = msg_data->y;
508         prev_data->info  = msg_data->info;
509     }
510     return 1;
511 }
512
513 /* free a result structure */
514 static void free_result( struct message_result *result )
515 {
516     if (result->timeout) remove_timeout_user( result->timeout );
517     free( result->data );
518     if (result->callback_msg) free_message( result->callback_msg );
519     if (result->hardware_msg) free_message( result->hardware_msg );
520     if (result->desktop) release_object( result->desktop );
521     free( result );
522 }
523
524 /* remove the result from the sender list it is on */
525 static inline void remove_result_from_sender( struct message_result *result )
526 {
527     assert( result->sender );
528
529     list_remove( &result->sender_entry );
530     result->sender = NULL;
531     if (!result->receiver) free_result( result );
532 }
533
534 /* store the message result in the appropriate structure */
535 static void store_message_result( struct message_result *res, lparam_t result, unsigned int error )
536 {
537     res->result  = result;
538     res->error   = error;
539     res->replied = 1;
540     if (res->timeout)
541     {
542         remove_timeout_user( res->timeout );
543         res->timeout = NULL;
544     }
545
546     if (res->hardware_msg)
547     {
548         if (!error && result)  /* rejected by the hook */
549             free_message( res->hardware_msg );
550         else
551             queue_hardware_message( res->desktop, res->hardware_msg, 0 );
552
553         res->hardware_msg = NULL;
554     }
555
556     if (res->sender)
557     {
558         if (res->callback_msg)
559         {
560             /* queue the callback message in the sender queue */
561             struct callback_msg_data *data = res->callback_msg->data;
562             data->result = result;
563             list_add_tail( &res->sender->msg_list[SEND_MESSAGE], &res->callback_msg->entry );
564             set_queue_bits( res->sender, QS_SENDMESSAGE );
565             res->callback_msg = NULL;
566             remove_result_from_sender( res );
567         }
568         else
569         {
570             /* wake sender queue if waiting on this result */
571             if (list_head(&res->sender->send_result) == &res->sender_entry)
572                 set_queue_bits( res->sender, QS_SMRESULT );
573         }
574     }
575     else if (!res->receiver) free_result( res );
576 }
577
578 /* free a message when deleting a queue or window */
579 static void free_message( struct message *msg )
580 {
581     struct message_result *result = msg->result;
582     if (result)
583     {
584         result->msg = NULL;
585         result->receiver = NULL;
586         store_message_result( result, 0, STATUS_ACCESS_DENIED /*FIXME*/ );
587     }
588     free( msg->data );
589     free( msg );
590 }
591
592 /* remove (and free) a message from a message list */
593 static void remove_queue_message( struct msg_queue *queue, struct message *msg,
594                                   enum message_kind kind )
595 {
596     list_remove( &msg->entry );
597     switch(kind)
598     {
599     case SEND_MESSAGE:
600         if (list_empty( &queue->msg_list[kind] )) clear_queue_bits( queue, QS_SENDMESSAGE );
601         break;
602     case POST_MESSAGE:
603         if (list_empty( &queue->msg_list[kind] ) && !queue->quit_message)
604             clear_queue_bits( queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
605         if (msg->msg == WM_HOTKEY && --queue->hotkey_count == 0)
606             clear_queue_bits( queue, QS_HOTKEY );
607         break;
608     }
609     free_message( msg );
610 }
611
612 /* message timed out without getting a reply */
613 static void result_timeout( void *private )
614 {
615     struct message_result *result = private;
616
617     assert( !result->replied );
618
619     result->timeout = NULL;
620
621     if (result->msg)  /* not received yet */
622     {
623         struct message *msg = result->msg;
624
625         result->msg = NULL;
626         msg->result = NULL;
627         remove_queue_message( result->receiver, msg, SEND_MESSAGE );
628         result->receiver = NULL;
629     }
630     store_message_result( result, 0, STATUS_TIMEOUT );
631 }
632
633 /* allocate and fill a message result structure */
634 static struct message_result *alloc_message_result( struct msg_queue *send_queue,
635                                                     struct msg_queue *recv_queue,
636                                                     struct message *msg, timeout_t timeout )
637 {
638     struct message_result *result = mem_alloc( sizeof(*result) );
639     if (result)
640     {
641         result->msg          = msg;
642         result->sender       = send_queue;
643         result->receiver     = recv_queue;
644         result->replied      = 0;
645         result->data         = NULL;
646         result->data_size    = 0;
647         result->timeout      = NULL;
648         result->hardware_msg = NULL;
649         result->desktop      = NULL;
650         result->callback_msg = NULL;
651
652         if (msg->type == MSG_CALLBACK)
653         {
654             struct message *callback_msg = mem_alloc( sizeof(*callback_msg) );
655
656             if (!callback_msg)
657             {
658                 free( result );
659                 return NULL;
660             }
661             callback_msg->type      = MSG_CALLBACK_RESULT;
662             callback_msg->win       = msg->win;
663             callback_msg->msg       = msg->msg;
664             callback_msg->wparam    = 0;
665             callback_msg->lparam    = 0;
666             callback_msg->time      = get_tick_count();
667             callback_msg->result    = NULL;
668             /* steal the data from the original message */
669             callback_msg->data      = msg->data;
670             callback_msg->data_size = msg->data_size;
671             msg->data = NULL;
672             msg->data_size = 0;
673
674             result->callback_msg = callback_msg;
675             list_add_head( &send_queue->callback_result, &result->sender_entry );
676         }
677         else if (send_queue) list_add_head( &send_queue->send_result, &result->sender_entry );
678
679         if (timeout != TIMEOUT_INFINITE)
680             result->timeout = add_timeout_user( timeout, result_timeout, result );
681     }
682     return result;
683 }
684
685 /* receive a message, removing it from the sent queue */
686 static void receive_message( struct msg_queue *queue, struct message *msg,
687                              struct get_message_reply *reply )
688 {
689     struct message_result *result = msg->result;
690
691     reply->total = msg->data_size;
692     if (msg->data_size > get_reply_max_size())
693     {
694         set_error( STATUS_BUFFER_OVERFLOW );
695         return;
696     }
697     reply->type   = msg->type;
698     reply->win    = msg->win;
699     reply->msg    = msg->msg;
700     reply->wparam = msg->wparam;
701     reply->lparam = msg->lparam;
702     reply->time   = msg->time;
703
704     if (msg->data) set_reply_data_ptr( msg->data, msg->data_size );
705
706     list_remove( &msg->entry );
707     /* put the result on the receiver result stack */
708     if (result)
709     {
710         result->msg = NULL;
711         result->recv_next  = queue->recv_result;
712         queue->recv_result = result;
713     }
714     free( msg );
715     if (list_empty( &queue->msg_list[SEND_MESSAGE] )) clear_queue_bits( queue, QS_SENDMESSAGE );
716 }
717
718 /* set the result of the current received message */
719 static void reply_message( struct msg_queue *queue, lparam_t result,
720                            unsigned int error, int remove, const void *data, data_size_t len )
721 {
722     struct message_result *res = queue->recv_result;
723
724     if (remove)
725     {
726         queue->recv_result = res->recv_next;
727         res->receiver = NULL;
728         if (!res->sender && !res->hardware_msg)  /* no one waiting for it */
729         {
730             free_result( res );
731             return;
732         }
733     }
734     if (!res->replied)
735     {
736         if (len && (res->data = memdup( data, len ))) res->data_size = len;
737         store_message_result( res, result, error );
738     }
739 }
740
741 static int match_window( user_handle_t win, user_handle_t msg_win )
742 {
743     if (!win) return 1;
744     if (win == -1 || win == 1) return !msg_win;
745     if (msg_win == win) return 1;
746     return is_child_window( win, msg_win );
747 }
748
749 /* retrieve a posted message */
750 static int get_posted_message( struct msg_queue *queue, user_handle_t win,
751                                unsigned int first, unsigned int last, unsigned int flags,
752                                struct get_message_reply *reply )
753 {
754     struct message *msg;
755
756     /* check against the filters */
757     LIST_FOR_EACH_ENTRY( msg, &queue->msg_list[POST_MESSAGE], struct message, entry )
758     {
759         if (!match_window( win, msg->win )) continue;
760         if (!check_msg_filter( msg->msg, first, last )) continue;
761         goto found; /* found one */
762     }
763     return 0;
764
765     /* return it to the app */
766 found:
767     reply->total = msg->data_size;
768     if (msg->data_size > get_reply_max_size())
769     {
770         set_error( STATUS_BUFFER_OVERFLOW );
771         return 1;
772     }
773     reply->type   = msg->type;
774     reply->win    = msg->win;
775     reply->msg    = msg->msg;
776     reply->wparam = msg->wparam;
777     reply->lparam = msg->lparam;
778     reply->time   = msg->time;
779
780     if (flags & PM_REMOVE)
781     {
782         if (msg->data)
783         {
784             set_reply_data_ptr( msg->data, msg->data_size );
785             msg->data = NULL;
786             msg->data_size = 0;
787         }
788         remove_queue_message( queue, msg, POST_MESSAGE );
789     }
790     else if (msg->data) set_reply_data( msg->data, msg->data_size );
791
792     return 1;
793 }
794
795 static int get_quit_message( struct msg_queue *queue, unsigned int flags,
796                              struct get_message_reply *reply )
797 {
798     if (queue->quit_message)
799     {
800         reply->total  = 0;
801         reply->type   = MSG_POSTED;
802         reply->win    = 0;
803         reply->msg    = WM_QUIT;
804         reply->wparam = queue->exit_code;
805         reply->lparam = 0;
806         reply->time   = get_tick_count();
807
808         if (flags & PM_REMOVE)
809         {
810             queue->quit_message = 0;
811             if (list_empty( &queue->msg_list[POST_MESSAGE] ))
812                 clear_queue_bits( queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
813         }
814         return 1;
815     }
816     else
817         return 0;
818 }
819
820 /* empty a message list and free all the messages */
821 static void empty_msg_list( struct list *list )
822 {
823     struct list *ptr;
824
825     while ((ptr = list_head( list )) != NULL)
826     {
827         struct message *msg = LIST_ENTRY( ptr, struct message, entry );
828         list_remove( &msg->entry );
829         free_message( msg );
830     }
831 }
832
833 /* cleanup all pending results when deleting a queue */
834 static void cleanup_results( struct msg_queue *queue )
835 {
836     struct list *entry;
837
838     while ((entry = list_head( &queue->send_result )) != NULL)
839     {
840         remove_result_from_sender( LIST_ENTRY( entry, struct message_result, sender_entry ) );
841     }
842
843     while ((entry = list_head( &queue->callback_result )) != NULL)
844     {
845         remove_result_from_sender( LIST_ENTRY( entry, struct message_result, sender_entry ) );
846     }
847
848     while (queue->recv_result)
849         reply_message( queue, 0, STATUS_ACCESS_DENIED /*FIXME*/, 1, NULL, 0 );
850 }
851
852 /* check if the thread owning the queue is hung (not checking for messages) */
853 static int is_queue_hung( struct msg_queue *queue )
854 {
855     struct wait_queue_entry *entry;
856
857     if (current_time - queue->last_get_msg <= 5 * TICKS_PER_SEC)
858         return 0;  /* less than 5 seconds since last get message -> not hung */
859
860     LIST_FOR_EACH_ENTRY( entry, &queue->obj.wait_queue, struct wait_queue_entry, entry )
861     {
862         if (entry->thread->queue == queue)
863             return 0;  /* thread is waiting on queue -> not hung */
864     }
865     return 1;
866 }
867
868 static int msg_queue_add_queue( struct object *obj, struct wait_queue_entry *entry )
869 {
870     struct msg_queue *queue = (struct msg_queue *)obj;
871     struct process *process = entry->thread->process;
872
873     /* a thread can only wait on its own queue */
874     if (entry->thread->queue != queue)
875     {
876         set_error( STATUS_ACCESS_DENIED );
877         return 0;
878     }
879     if (process->idle_event && !(queue->wake_mask & QS_SMRESULT)) set_event( process->idle_event );
880
881     if (queue->fd && list_empty( &obj->wait_queue ))  /* first on the queue */
882         set_fd_events( queue->fd, POLLIN );
883     add_queue( obj, entry );
884     return 1;
885 }
886
887 static void msg_queue_remove_queue(struct object *obj, struct wait_queue_entry *entry )
888 {
889     struct msg_queue *queue = (struct msg_queue *)obj;
890
891     remove_queue( obj, entry );
892     if (queue->fd && list_empty( &obj->wait_queue ))  /* last on the queue is gone */
893         set_fd_events( queue->fd, 0 );
894 }
895
896 static void msg_queue_dump( struct object *obj, int verbose )
897 {
898     struct msg_queue *queue = (struct msg_queue *)obj;
899     fprintf( stderr, "Msg queue bits=%x mask=%x\n",
900              queue->wake_bits, queue->wake_mask );
901 }
902
903 static int msg_queue_signaled( struct object *obj, struct thread *thread )
904 {
905     struct msg_queue *queue = (struct msg_queue *)obj;
906     int ret = 0;
907
908     if (queue->fd)
909     {
910         if ((ret = check_fd_events( queue->fd, POLLIN )))
911             /* stop waiting on select() if we are signaled */
912             set_fd_events( queue->fd, 0 );
913         else if (!list_empty( &obj->wait_queue ))
914             /* restart waiting on poll() if we are no longer signaled */
915             set_fd_events( queue->fd, POLLIN );
916     }
917     return ret || is_signaled( queue );
918 }
919
920 static int msg_queue_satisfied( struct object *obj, struct thread *thread )
921 {
922     struct msg_queue *queue = (struct msg_queue *)obj;
923     queue->wake_mask = 0;
924     queue->changed_mask = 0;
925     return 0;  /* Not abandoned */
926 }
927
928 static void msg_queue_destroy( struct object *obj )
929 {
930     struct msg_queue *queue = (struct msg_queue *)obj;
931     struct list *ptr;
932     struct hotkey *hotkey, *hotkey2;
933     int i;
934
935     cleanup_results( queue );
936     for (i = 0; i < NB_MSG_KINDS; i++) empty_msg_list( &queue->msg_list[i] );
937
938     LIST_FOR_EACH_ENTRY_SAFE( hotkey, hotkey2, &queue->input->desktop->hotkeys, struct hotkey, entry )
939     {
940         if (hotkey->queue == queue)
941         {
942             list_remove( &hotkey->entry );
943             free( hotkey );
944         }
945     }
946
947     while ((ptr = list_head( &queue->pending_timers )))
948     {
949         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
950         list_remove( &timer->entry );
951         free( timer );
952     }
953     while ((ptr = list_head( &queue->expired_timers )))
954     {
955         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
956         list_remove( &timer->entry );
957         free( timer );
958     }
959     if (queue->timeout) remove_timeout_user( queue->timeout );
960     queue->input->cursor_count -= queue->cursor_count;
961     release_object( queue->input );
962     if (queue->hooks) release_object( queue->hooks );
963     if (queue->fd) release_object( queue->fd );
964 }
965
966 static void msg_queue_poll_event( struct fd *fd, int event )
967 {
968     struct msg_queue *queue = get_fd_user( fd );
969     assert( queue->obj.ops == &msg_queue_ops );
970
971     if (event & (POLLERR | POLLHUP)) set_fd_events( fd, -1 );
972     else set_fd_events( queue->fd, 0 );
973     wake_up( &queue->obj, 0 );
974 }
975
976 static void thread_input_dump( struct object *obj, int verbose )
977 {
978     struct thread_input *input = (struct thread_input *)obj;
979     fprintf( stderr, "Thread input focus=%08x capture=%08x active=%08x\n",
980              input->focus, input->capture, input->active );
981 }
982
983 static void thread_input_destroy( struct object *obj )
984 {
985     struct thread_input *input = (struct thread_input *)obj;
986
987     empty_msg_list( &input->msg_list );
988     if (input->desktop)
989     {
990         if (input->desktop->foreground_input == input) set_foreground_input( input->desktop, NULL );
991         release_object( input->desktop );
992     }
993 }
994
995 /* fix the thread input data when a window is destroyed */
996 static inline void thread_input_cleanup_window( struct msg_queue *queue, user_handle_t window )
997 {
998     struct thread_input *input = queue->input;
999
1000     if (window == input->focus) input->focus = 0;
1001     if (window == input->capture) input->capture = 0;
1002     if (window == input->active) input->active = 0;
1003     if (window == input->menu_owner) input->menu_owner = 0;
1004     if (window == input->move_size) input->move_size = 0;
1005     if (window == input->caret) set_caret_window( input, 0 );
1006 }
1007
1008 /* check if the specified window can be set in the input data of a given queue */
1009 static int check_queue_input_window( struct msg_queue *queue, user_handle_t window )
1010 {
1011     struct thread *thread;
1012     int ret = 0;
1013
1014     if (!window) return 1;  /* we can always clear the data */
1015
1016     if ((thread = get_window_thread( window )))
1017     {
1018         ret = (queue->input == thread->queue->input);
1019         if (!ret) set_error( STATUS_ACCESS_DENIED );
1020         release_object( thread );
1021     }
1022     else set_error( STATUS_INVALID_HANDLE );
1023
1024     return ret;
1025 }
1026
1027 /* make sure the specified thread has a queue */
1028 int init_thread_queue( struct thread *thread )
1029 {
1030     if (thread->queue) return 1;
1031     return (create_msg_queue( thread, NULL ) != NULL);
1032 }
1033
1034 /* attach two thread input data structures */
1035 int attach_thread_input( struct thread *thread_from, struct thread *thread_to )
1036 {
1037     struct desktop *desktop;
1038     struct thread_input *input;
1039     int ret;
1040
1041     if (!thread_to->queue && !(thread_to->queue = create_msg_queue( thread_to, NULL ))) return 0;
1042     if (!(desktop = get_thread_desktop( thread_from, 0 ))) return 0;
1043     input = (struct thread_input *)grab_object( thread_to->queue->input );
1044     if (input->desktop != desktop)
1045     {
1046         set_error( STATUS_ACCESS_DENIED );
1047         release_object( input );
1048         release_object( desktop );
1049         return 0;
1050     }
1051     release_object( desktop );
1052
1053     ret = assign_thread_input( thread_from, input );
1054     if (ret) memset( input->keystate, 0, sizeof(input->keystate) );
1055     release_object( input );
1056     return ret;
1057 }
1058
1059 /* detach two thread input data structures */
1060 void detach_thread_input( struct thread *thread_from )
1061 {
1062     struct thread_input *input;
1063
1064     if ((input = create_thread_input( thread_from )))
1065     {
1066         assign_thread_input( thread_from, input );
1067         release_object( input );
1068     }
1069 }
1070
1071
1072 /* set the next timer to expire */
1073 static void set_next_timer( struct msg_queue *queue )
1074 {
1075     struct list *ptr;
1076
1077     if (queue->timeout)
1078     {
1079         remove_timeout_user( queue->timeout );
1080         queue->timeout = NULL;
1081     }
1082     if ((ptr = list_head( &queue->pending_timers )))
1083     {
1084         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1085         queue->timeout = add_timeout_user( timer->when, timer_callback, queue );
1086     }
1087     /* set/clear QS_TIMER bit */
1088     if (list_empty( &queue->expired_timers ))
1089         clear_queue_bits( queue, QS_TIMER );
1090     else
1091         set_queue_bits( queue, QS_TIMER );
1092 }
1093
1094 /* find a timer from its window and id */
1095 static struct timer *find_timer( struct msg_queue *queue, user_handle_t win,
1096                                  unsigned int msg, lparam_t id )
1097 {
1098     struct list *ptr;
1099
1100     /* we need to search both lists */
1101
1102     LIST_FOR_EACH( ptr, &queue->pending_timers )
1103     {
1104         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1105         if (timer->win == win && timer->msg == msg && timer->id == id) return timer;
1106     }
1107     LIST_FOR_EACH( ptr, &queue->expired_timers )
1108     {
1109         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1110         if (timer->win == win && timer->msg == msg && timer->id == id) return timer;
1111     }
1112     return NULL;
1113 }
1114
1115 /* callback for the next timer expiration */
1116 static void timer_callback( void *private )
1117 {
1118     struct msg_queue *queue = private;
1119     struct list *ptr;
1120
1121     queue->timeout = NULL;
1122     /* move on to the next timer */
1123     ptr = list_head( &queue->pending_timers );
1124     list_remove( ptr );
1125     list_add_tail( &queue->expired_timers, ptr );
1126     set_next_timer( queue );
1127 }
1128
1129 /* link a timer at its rightful place in the queue list */
1130 static void link_timer( struct msg_queue *queue, struct timer *timer )
1131 {
1132     struct list *ptr;
1133
1134     for (ptr = queue->pending_timers.next; ptr != &queue->pending_timers; ptr = ptr->next)
1135     {
1136         struct timer *t = LIST_ENTRY( ptr, struct timer, entry );
1137         if (t->when >= timer->when) break;
1138     }
1139     list_add_before( ptr, &timer->entry );
1140 }
1141
1142 /* remove a timer from the queue timer list and free it */
1143 static void free_timer( struct msg_queue *queue, struct timer *timer )
1144 {
1145     list_remove( &timer->entry );
1146     free( timer );
1147     set_next_timer( queue );
1148 }
1149
1150 /* restart an expired timer */
1151 static void restart_timer( struct msg_queue *queue, struct timer *timer )
1152 {
1153     list_remove( &timer->entry );
1154     while (timer->when <= current_time) timer->when += (timeout_t)timer->rate * 10000;
1155     link_timer( queue, timer );
1156     set_next_timer( queue );
1157 }
1158
1159 /* find an expired timer matching the filtering parameters */
1160 static struct timer *find_expired_timer( struct msg_queue *queue, user_handle_t win,
1161                                          unsigned int get_first, unsigned int get_last,
1162                                          int remove )
1163 {
1164     struct list *ptr;
1165
1166     LIST_FOR_EACH( ptr, &queue->expired_timers )
1167     {
1168         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1169         if (win && timer->win != win) continue;
1170         if (check_msg_filter( timer->msg, get_first, get_last ))
1171         {
1172             if (remove) restart_timer( queue, timer );
1173             return timer;
1174         }
1175     }
1176     return NULL;
1177 }
1178
1179 /* add a timer */
1180 static struct timer *set_timer( struct msg_queue *queue, unsigned int rate )
1181 {
1182     struct timer *timer = mem_alloc( sizeof(*timer) );
1183     if (timer)
1184     {
1185         timer->rate = max( rate, 1 );
1186         timer->when = current_time + (timeout_t)timer->rate * 10000;
1187         link_timer( queue, timer );
1188         /* check if we replaced the next timer */
1189         if (list_head( &queue->pending_timers ) == &timer->entry) set_next_timer( queue );
1190     }
1191     return timer;
1192 }
1193
1194 /* change the input key state for a given key */
1195 static void set_input_key_state( unsigned char *keystate, unsigned char key, int down )
1196 {
1197     if (down)
1198     {
1199         if (!(keystate[key] & 0x80)) keystate[key] ^= 0x01;
1200         keystate[key] |= down;
1201     }
1202     else keystate[key] &= ~0x80;
1203 }
1204
1205 /* update the input key state for a keyboard message */
1206 static void update_input_key_state( struct desktop *desktop, unsigned char *keystate,
1207                                     const struct message *msg )
1208 {
1209     unsigned char key;
1210     int down = 0;
1211
1212     switch (msg->msg)
1213     {
1214     case WM_LBUTTONDOWN:
1215         down = (keystate == desktop->keystate) ? 0xc0 : 0x80;
1216         /* fall through */
1217     case WM_LBUTTONUP:
1218         set_input_key_state( keystate, VK_LBUTTON, down );
1219         break;
1220     case WM_MBUTTONDOWN:
1221         down = (keystate == desktop->keystate) ? 0xc0 : 0x80;
1222         /* fall through */
1223     case WM_MBUTTONUP:
1224         set_input_key_state( keystate, VK_MBUTTON, down );
1225         break;
1226     case WM_RBUTTONDOWN:
1227         down = (keystate == desktop->keystate) ? 0xc0 : 0x80;
1228         /* fall through */
1229     case WM_RBUTTONUP:
1230         set_input_key_state( keystate, VK_RBUTTON, down );
1231         break;
1232     case WM_XBUTTONDOWN:
1233         down = (keystate == desktop->keystate) ? 0xc0 : 0x80;
1234         /* fall through */
1235     case WM_XBUTTONUP:
1236         if (msg->wparam >> 16 == XBUTTON1) set_input_key_state( keystate, VK_XBUTTON1, down );
1237         else if (msg->wparam >> 16 == XBUTTON2) set_input_key_state( keystate, VK_XBUTTON2, down );
1238         break;
1239     case WM_KEYDOWN:
1240     case WM_SYSKEYDOWN:
1241         down = (keystate == desktop->keystate) ? 0xc0 : 0x80;
1242         /* fall through */
1243     case WM_KEYUP:
1244     case WM_SYSKEYUP:
1245         key = (unsigned char)msg->wparam;
1246         set_input_key_state( keystate, key, down );
1247         switch(key)
1248         {
1249         case VK_LCONTROL:
1250         case VK_RCONTROL:
1251             down = (keystate[VK_LCONTROL] | keystate[VK_RCONTROL]) & 0x80;
1252             set_input_key_state( keystate, VK_CONTROL, down );
1253             break;
1254         case VK_LMENU:
1255         case VK_RMENU:
1256             down = (keystate[VK_LMENU] | keystate[VK_RMENU]) & 0x80;
1257             set_input_key_state( keystate, VK_MENU, down );
1258             break;
1259         case VK_LSHIFT:
1260         case VK_RSHIFT:
1261             down = (keystate[VK_LSHIFT] | keystate[VK_RSHIFT]) & 0x80;
1262             set_input_key_state( keystate, VK_SHIFT, down );
1263             break;
1264         }
1265         break;
1266     }
1267 }
1268
1269 /* release the hardware message currently being processed by the given thread */
1270 static void release_hardware_message( struct msg_queue *queue, unsigned int hw_id,
1271                                       int remove, user_handle_t new_win )
1272 {
1273     struct thread_input *input = queue->input;
1274     struct message *msg;
1275
1276     LIST_FOR_EACH_ENTRY( msg, &input->msg_list, struct message, entry )
1277     {
1278         if (msg->unique_id == hw_id) break;
1279     }
1280     if (&msg->entry == &input->msg_list) return;  /* not found */
1281
1282     /* clear the queue bit for that message */
1283     if (remove || new_win)
1284     {
1285         struct message *other;
1286         int clr_bit;
1287
1288         clr_bit = get_hardware_msg_bit( msg );
1289         LIST_FOR_EACH_ENTRY( other, &input->msg_list, struct message, entry )
1290         {
1291             if (other != msg && get_hardware_msg_bit( other ) == clr_bit)
1292             {
1293                 clr_bit = 0;
1294                 break;
1295             }
1296         }
1297         if (clr_bit) clear_queue_bits( queue, clr_bit );
1298     }
1299
1300     if (new_win)  /* set the new window */
1301     {
1302         struct thread *owner = get_window_thread( new_win );
1303         if (owner)
1304         {
1305             msg->win = new_win;
1306             if (owner->queue->input != input)
1307             {
1308                 list_remove( &msg->entry );
1309                 if (merge_message( owner->queue->input, msg ))
1310                 {
1311                     free_message( msg );
1312                     release_object( owner );
1313                     return;
1314                 }
1315                 list_add_tail( &owner->queue->input->msg_list, &msg->entry );
1316             }
1317             set_queue_bits( owner->queue, get_hardware_msg_bit( msg ));
1318             remove = 0;
1319             release_object( owner );
1320         }
1321     }
1322     if (remove)
1323     {
1324         update_input_key_state( input->desktop, input->keystate, msg );
1325         list_remove( &msg->entry );
1326         free_message( msg );
1327     }
1328 }
1329
1330 static int queue_hotkey_message( struct desktop *desktop, struct message *msg )
1331 {
1332     struct hotkey *hotkey;
1333     unsigned int modifiers = 0;
1334
1335     if (msg->msg != WM_KEYDOWN) return 0;
1336
1337     if (desktop->keystate[VK_MENU] & 0x80) modifiers |= MOD_ALT;
1338     if (desktop->keystate[VK_CONTROL] & 0x80) modifiers |= MOD_CONTROL;
1339     if (desktop->keystate[VK_SHIFT] & 0x80) modifiers |= MOD_SHIFT;
1340     if ((desktop->keystate[VK_LWIN] & 0x80) || (desktop->keystate[VK_RWIN] & 0x80)) modifiers |= MOD_WIN;
1341
1342     LIST_FOR_EACH_ENTRY( hotkey, &desktop->hotkeys, struct hotkey, entry )
1343     {
1344         if (hotkey->vkey != msg->wparam) continue;
1345         if ((hotkey->flags & (MOD_ALT|MOD_CONTROL|MOD_SHIFT|MOD_WIN)) == modifiers) goto found;
1346     }
1347
1348     return 0;
1349
1350 found:
1351     msg->type      = MSG_POSTED;
1352     msg->win       = hotkey->win;
1353     msg->msg       = WM_HOTKEY;
1354     msg->wparam    = hotkey->id;
1355     msg->lparam    = ((hotkey->vkey & 0xffff) << 16) | modifiers;
1356
1357     free( msg->data );
1358     msg->data      = NULL;
1359     msg->data_size = 0;
1360
1361     list_add_tail( &hotkey->queue->msg_list[POST_MESSAGE], &msg->entry );
1362     set_queue_bits( hotkey->queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE|QS_HOTKEY );
1363     hotkey->queue->hotkey_count++;
1364     return 1;
1365 }
1366
1367 /* find the window that should receive a given hardware message */
1368 static user_handle_t find_hardware_message_window( struct desktop *desktop, struct thread_input *input,
1369                                                    struct message *msg, unsigned int *msg_code )
1370 {
1371     struct hardware_msg_data *data = msg->data;
1372     user_handle_t win = 0;
1373
1374     *msg_code = msg->msg;
1375     if (is_keyboard_msg( msg ))
1376     {
1377         if (input && !(win = input->focus))
1378         {
1379             win = input->active;
1380             if (*msg_code < WM_SYSKEYDOWN) *msg_code += WM_SYSKEYDOWN - WM_KEYDOWN;
1381         }
1382     }
1383     else  /* mouse message */
1384     {
1385         if (!input || !(win = input->capture))
1386         {
1387             if (!(win = msg->win) || !is_window_visible( win ) || is_window_transparent( win ))
1388                 win = window_from_point( desktop, data->x, data->y );
1389         }
1390     }
1391     return win;
1392 }
1393
1394 /* queue a hardware message into a given thread input */
1395 static void queue_hardware_message( struct desktop *desktop, struct message *msg, int always_queue )
1396 {
1397     user_handle_t win;
1398     struct thread *thread;
1399     struct thread_input *input;
1400     unsigned int msg_code;
1401     struct hardware_msg_data *data = msg->data;
1402
1403     update_input_key_state( desktop, desktop->keystate, msg );
1404     last_input_time = get_tick_count();
1405     if (msg->msg != WM_MOUSEMOVE) always_queue = 1;
1406
1407     if (is_keyboard_msg( msg ))
1408     {
1409         if (queue_hotkey_message( desktop, msg )) return;
1410         if (desktop->keystate[VK_MENU] & 0x80) msg->lparam |= KF_ALTDOWN << 16;
1411         if (msg->wparam == VK_SHIFT || msg->wparam == VK_LSHIFT || msg->wparam == VK_RSHIFT)
1412             msg->lparam &= ~(KF_EXTENDED << 16);
1413     }
1414     else
1415     {
1416         if (msg->msg == WM_MOUSEMOVE)
1417         {
1418             int x = min( max( data->x, desktop->cursor.clip.left ), desktop->cursor.clip.right-1 );
1419             int y = min( max( data->y, desktop->cursor.clip.top ), desktop->cursor.clip.bottom-1 );
1420             if (desktop->cursor.x != x || desktop->cursor.y != y) always_queue = 1;
1421             desktop->cursor.x = x;
1422             desktop->cursor.y = y;
1423             desktop->cursor.last_change = get_tick_count();
1424         }
1425         if (desktop->keystate[VK_LBUTTON] & 0x80)  msg->wparam |= MK_LBUTTON;
1426         if (desktop->keystate[VK_MBUTTON] & 0x80)  msg->wparam |= MK_MBUTTON;
1427         if (desktop->keystate[VK_RBUTTON] & 0x80)  msg->wparam |= MK_RBUTTON;
1428         if (desktop->keystate[VK_SHIFT] & 0x80)    msg->wparam |= MK_SHIFT;
1429         if (desktop->keystate[VK_CONTROL] & 0x80)  msg->wparam |= MK_CONTROL;
1430         if (desktop->keystate[VK_XBUTTON1] & 0x80) msg->wparam |= MK_XBUTTON1;
1431         if (desktop->keystate[VK_XBUTTON2] & 0x80) msg->wparam |= MK_XBUTTON2;
1432     }
1433     data->x = desktop->cursor.x;
1434     data->y = desktop->cursor.y;
1435
1436     if (msg->win && (thread = get_window_thread( msg->win )))
1437     {
1438         input = thread->queue->input;
1439         release_object( thread );
1440     }
1441     else input = desktop->foreground_input;
1442
1443     win = find_hardware_message_window( desktop, input, msg, &msg_code );
1444     if (!win || !(thread = get_window_thread(win)))
1445     {
1446         if (input) update_input_key_state( input->desktop, input->keystate, msg );
1447         free_message( msg );
1448         return;
1449     }
1450     input = thread->queue->input;
1451
1452     if (win != desktop->cursor.win) always_queue = 1;
1453     desktop->cursor.win = win;
1454
1455     if (!always_queue || merge_message( input, msg )) free_message( msg );
1456     else
1457     {
1458         msg->unique_id = 0;  /* will be set once we return it to the app */
1459         list_add_tail( &input->msg_list, &msg->entry );
1460         set_queue_bits( thread->queue, get_hardware_msg_bit(msg) );
1461     }
1462     release_object( thread );
1463 }
1464
1465 /* send the low-level hook message for a given hardware message */
1466 static int send_hook_ll_message( struct desktop *desktop, struct message *hardware_msg,
1467                                  const hw_input_t *input, struct msg_queue *sender )
1468 {
1469     struct thread *hook_thread;
1470     struct msg_queue *queue;
1471     struct message *msg;
1472     timeout_t timeout = 2000 * -10000;  /* FIXME: load from registry */
1473     int id = (input->type == INPUT_MOUSE) ? WH_MOUSE_LL : WH_KEYBOARD_LL;
1474
1475     if (!(hook_thread = get_first_global_hook( id ))) return 0;
1476     if (!(queue = hook_thread->queue)) return 0;
1477     if (is_queue_hung( queue )) return 0;
1478
1479     if (!(msg = mem_alloc( sizeof(*msg) ))) return 0;
1480
1481     msg->type      = MSG_HOOK_LL;
1482     msg->win       = 0;
1483     msg->msg       = id;
1484     msg->wparam    = hardware_msg->msg;
1485     msg->time      = hardware_msg->time;
1486     msg->data_size = hardware_msg->data_size;
1487     msg->result    = NULL;
1488
1489     if (input->type == INPUT_KEYBOARD)
1490     {
1491         unsigned short vkey = input->kbd.vkey;
1492         if (input->kbd.flags & KEYEVENTF_UNICODE) vkey = VK_PACKET;
1493         msg->lparam = (input->kbd.scan << 16) | vkey;
1494     }
1495     else msg->lparam = input->mouse.data << 16;
1496
1497     if (!(msg->data = memdup( hardware_msg->data, hardware_msg->data_size )) ||
1498         !(msg->result = alloc_message_result( sender, queue, msg, timeout )))
1499     {
1500         free_message( msg );
1501         return 0;
1502     }
1503     msg->result->hardware_msg = hardware_msg;
1504     msg->result->desktop = (struct desktop *)grab_object( desktop );
1505     list_add_tail( &queue->msg_list[SEND_MESSAGE], &msg->entry );
1506     set_queue_bits( queue, QS_SENDMESSAGE );
1507     return 1;
1508 }
1509
1510 /* queue a hardware message for a mouse event */
1511 static int queue_mouse_message( struct desktop *desktop, user_handle_t win, const hw_input_t *input,
1512                                 unsigned int hook_flags, struct msg_queue *sender )
1513 {
1514     struct hardware_msg_data *msg_data;
1515     struct message *msg;
1516     unsigned int i, time, flags;
1517     int wait = 0, x, y;
1518
1519     static const unsigned int messages[] =
1520     {
1521         WM_MOUSEMOVE,    /* 0x0001 = MOUSEEVENTF_MOVE */
1522         WM_LBUTTONDOWN,  /* 0x0002 = MOUSEEVENTF_LEFTDOWN */
1523         WM_LBUTTONUP,    /* 0x0004 = MOUSEEVENTF_LEFTUP */
1524         WM_RBUTTONDOWN,  /* 0x0008 = MOUSEEVENTF_RIGHTDOWN */
1525         WM_RBUTTONUP,    /* 0x0010 = MOUSEEVENTF_RIGHTUP */
1526         WM_MBUTTONDOWN,  /* 0x0020 = MOUSEEVENTF_MIDDLEDOWN */
1527         WM_MBUTTONUP,    /* 0x0040 = MOUSEEVENTF_MIDDLEUP */
1528         WM_XBUTTONDOWN,  /* 0x0080 = MOUSEEVENTF_XDOWN */
1529         WM_XBUTTONUP,    /* 0x0100 = MOUSEEVENTF_XUP */
1530         0,               /* 0x0200 = unused */
1531         0,               /* 0x0400 = unused */
1532         WM_MOUSEWHEEL,   /* 0x0800 = MOUSEEVENTF_WHEEL */
1533         WM_MOUSEHWHEEL   /* 0x1000 = MOUSEEVENTF_HWHEEL */
1534     };
1535
1536     desktop->cursor.last_change = get_tick_count();
1537     flags = input->mouse.flags;
1538     time  = input->mouse.time;
1539     if (!time) time = desktop->cursor.last_change;
1540
1541     if (flags & MOUSEEVENTF_MOVE)
1542     {
1543         if (flags & MOUSEEVENTF_ABSOLUTE)
1544         {
1545             x = input->mouse.x;
1546             y = input->mouse.y;
1547             if (flags & ~(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE) &&
1548                 x == desktop->cursor.x && y == desktop->cursor.y)
1549                 flags &= ~MOUSEEVENTF_MOVE;
1550         }
1551         else
1552         {
1553             x = desktop->cursor.x + input->mouse.x;
1554             y = desktop->cursor.y + input->mouse.y;
1555         }
1556     }
1557     else
1558     {
1559         x = desktop->cursor.x;
1560         y = desktop->cursor.y;
1561     }
1562
1563     for (i = 0; i < sizeof(messages)/sizeof(messages[0]); i++)
1564     {
1565         if (!messages[i]) continue;
1566         if (!(flags & (1 << i))) continue;
1567         flags &= ~(1 << i);
1568
1569         if (!(msg = mem_alloc( sizeof(*msg) ))) return 0;
1570         if (!(msg_data = mem_alloc( sizeof(*msg_data) )))
1571         {
1572             free( msg );
1573             return 0;
1574         }
1575         memset( msg_data, 0, sizeof(*msg_data) );
1576
1577         msg->type      = MSG_HARDWARE;
1578         msg->win       = get_user_full_handle( win );
1579         msg->msg       = messages[i];
1580         msg->wparam    = input->mouse.data << 16;
1581         msg->lparam    = 0;
1582         msg->time      = time;
1583         msg->result    = NULL;
1584         msg->data      = msg_data;
1585         msg->data_size = sizeof(*msg_data);
1586         msg_data->x    = x;
1587         msg_data->y    = y;
1588         msg_data->info = input->mouse.info;
1589         if (hook_flags & SEND_HWMSG_INJECTED) msg_data->flags = LLMHF_INJECTED;
1590
1591         /* specify a sender only when sending the last message */
1592         if (!(flags & ((1 << sizeof(messages)/sizeof(messages[0])) - 1)))
1593         {
1594             if (!(wait = send_hook_ll_message( desktop, msg, input, sender )))
1595                 queue_hardware_message( desktop, msg, 0 );
1596         }
1597         else if (!send_hook_ll_message( desktop, msg, input, NULL ))
1598             queue_hardware_message( desktop, msg, 0 );
1599     }
1600     return wait;
1601 }
1602
1603 /* queue a hardware message for a keyboard event */
1604 static int queue_keyboard_message( struct desktop *desktop, user_handle_t win, const hw_input_t *input,
1605                                    unsigned int hook_flags, struct msg_queue *sender )
1606 {
1607     struct hardware_msg_data *msg_data;
1608     struct message *msg;
1609     unsigned char vkey = input->kbd.vkey;
1610     int wait;
1611
1612     if (!(msg = mem_alloc( sizeof(*msg) ))) return 0;
1613     if (!(msg_data = mem_alloc( sizeof(*msg_data) )))
1614     {
1615         free( msg );
1616         return 0;
1617     }
1618     memset( msg_data, 0, sizeof(*msg_data) );
1619
1620     msg->type      = MSG_HARDWARE;
1621     msg->win       = get_user_full_handle( win );
1622     msg->lparam    = (input->kbd.scan << 16) | 1u; /* repeat count */
1623     msg->time      = input->kbd.time;
1624     msg->result    = NULL;
1625     msg->data      = msg_data;
1626     msg->data_size = sizeof(*msg_data);
1627     msg_data->info = input->kbd.info;
1628     if (!msg->time) msg->time = get_tick_count();
1629     if (hook_flags & SEND_HWMSG_INJECTED) msg_data->flags = LLKHF_INJECTED;
1630
1631     if (input->kbd.flags & KEYEVENTF_UNICODE)
1632     {
1633         msg->wparam = VK_PACKET;
1634     }
1635     else
1636     {
1637         unsigned int flags = 0;
1638         switch (vkey)
1639         {
1640         case VK_MENU:
1641         case VK_LMENU:
1642         case VK_RMENU:
1643             vkey = (input->kbd.flags & KEYEVENTF_EXTENDEDKEY) ? VK_RMENU : VK_LMENU;
1644             break;
1645         case VK_CONTROL:
1646         case VK_LCONTROL:
1647         case VK_RCONTROL:
1648             vkey = (input->kbd.flags & KEYEVENTF_EXTENDEDKEY) ? VK_RCONTROL : VK_LCONTROL;
1649             break;
1650         case VK_SHIFT:
1651         case VK_LSHIFT:
1652         case VK_RSHIFT:
1653             vkey = (input->kbd.flags & KEYEVENTF_EXTENDEDKEY) ? VK_RSHIFT : VK_LSHIFT;
1654             break;
1655         }
1656         if (input->kbd.flags & KEYEVENTF_EXTENDEDKEY) flags |= KF_EXTENDED;
1657         /* FIXME: set KF_DLGMODE and KF_MENUMODE when needed */
1658         if (input->kbd.flags & KEYEVENTF_KEYUP) flags |= KF_REPEAT | KF_UP;
1659         else if (desktop->keystate[vkey] & 0x80) flags |= KF_REPEAT;
1660
1661         msg->wparam = vkey;
1662         msg->lparam |= flags << 16;
1663         msg_data->flags |= (flags & (KF_EXTENDED | KF_ALTDOWN | KF_UP)) >> 8;
1664     }
1665
1666     msg->msg = (input->kbd.flags & KEYEVENTF_KEYUP) ? WM_KEYUP : WM_KEYDOWN;
1667
1668     switch (vkey)
1669     {
1670     case VK_LMENU:
1671     case VK_RMENU:
1672         if (input->kbd.flags & KEYEVENTF_KEYUP)
1673         {
1674             /* send WM_SYSKEYUP if Alt still pressed and no other key in between */
1675             /* we use 0x02 as a flag to track if some other SYSKEYUP was sent already */
1676             if ((desktop->keystate[VK_MENU] & 0x82) != 0x82) break;
1677             msg->msg = WM_SYSKEYUP;
1678             desktop->keystate[VK_MENU] &= ~0x02;
1679         }
1680         else
1681         {
1682             /* send WM_SYSKEYDOWN for Alt except with Ctrl */
1683             if (desktop->keystate[VK_CONTROL] & 0x80) break;
1684             msg->msg = WM_SYSKEYDOWN;
1685             desktop->keystate[VK_MENU] |= 0x02;
1686         }
1687         break;
1688
1689     case VK_LCONTROL:
1690     case VK_RCONTROL:
1691         /* send WM_SYSKEYUP on release if Alt still pressed */
1692         if (!(input->kbd.flags & KEYEVENTF_KEYUP)) break;
1693         if (!(desktop->keystate[VK_MENU] & 0x80)) break;
1694         msg->msg = WM_SYSKEYUP;
1695         desktop->keystate[VK_MENU] &= ~0x02;
1696         break;
1697
1698     default:
1699         /* send WM_SYSKEY for Alt-anykey and for F10 */
1700         if (desktop->keystate[VK_CONTROL] & 0x80) break;
1701         if (!(desktop->keystate[VK_MENU] & 0x80)) break;
1702         /* fall through */
1703     case VK_F10:
1704         msg->msg = (input->kbd.flags & KEYEVENTF_KEYUP) ? WM_SYSKEYUP : WM_SYSKEYDOWN;
1705         desktop->keystate[VK_MENU] &= ~0x02;
1706         break;
1707     }
1708     if (!(wait = send_hook_ll_message( desktop, msg, input, sender )))
1709         queue_hardware_message( desktop, msg, 1 );
1710
1711     return wait;
1712 }
1713
1714 /* queue a hardware message for a custom type of event */
1715 static void queue_custom_hardware_message( struct desktop *desktop, user_handle_t win,
1716                                            const hw_input_t *input )
1717 {
1718     struct hardware_msg_data *msg_data;
1719     struct message *msg;
1720
1721     if (!(msg = mem_alloc( sizeof(*msg) ))) return;
1722     if (!(msg_data = mem_alloc( sizeof(*msg_data) )))
1723     {
1724         free( msg );
1725         return;
1726     }
1727     memset( msg_data, 0, sizeof(*msg_data) );
1728
1729     msg->type      = MSG_HARDWARE;
1730     msg->win       = get_user_full_handle( win );
1731     msg->msg       = input->hw.msg;
1732     msg->wparam    = 0;
1733     msg->lparam    = input->hw.lparam;
1734     msg->time      = get_tick_count();
1735     msg->result    = NULL;
1736     msg->data      = msg_data;
1737     msg->data_size = sizeof(*msg_data);
1738
1739     queue_hardware_message( desktop, msg, 1 );
1740 }
1741
1742 /* check message filter for a hardware message */
1743 static int check_hw_message_filter( user_handle_t win, unsigned int msg_code,
1744                                     user_handle_t filter_win, unsigned int first, unsigned int last )
1745 {
1746     if (msg_code >= WM_KEYFIRST && msg_code <= WM_KEYLAST)
1747     {
1748         /* we can only test the window for a keyboard message since the
1749          * dest window for a mouse message depends on hittest */
1750         if (filter_win && win != filter_win && !is_child_window( filter_win, win ))
1751             return 0;
1752         /* the message code is final for a keyboard message, we can simply check it */
1753         return check_msg_filter( msg_code, first, last );
1754     }
1755     else  /* mouse message */
1756     {
1757         /* we need to check all possible values that the message can have in the end */
1758
1759         if (check_msg_filter( msg_code, first, last )) return 1;
1760         if (msg_code == WM_MOUSEWHEEL) return 0;  /* no other possible value for this one */
1761
1762         /* all other messages can become non-client messages */
1763         if (check_msg_filter( msg_code + (WM_NCMOUSEFIRST - WM_MOUSEFIRST), first, last )) return 1;
1764
1765         /* clicks can become double-clicks or non-client double-clicks */
1766         if (msg_code == WM_LBUTTONDOWN || msg_code == WM_MBUTTONDOWN ||
1767             msg_code == WM_RBUTTONDOWN || msg_code == WM_XBUTTONDOWN)
1768         {
1769             if (check_msg_filter( msg_code + (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN), first, last )) return 1;
1770             if (check_msg_filter( msg_code + (WM_NCLBUTTONDBLCLK - WM_LBUTTONDOWN), first, last )) return 1;
1771         }
1772         return 0;
1773     }
1774 }
1775
1776
1777 /* find a hardware message for the given queue */
1778 static int get_hardware_message( struct thread *thread, unsigned int hw_id, user_handle_t filter_win,
1779                                  unsigned int first, unsigned int last, struct get_message_reply *reply )
1780 {
1781     struct thread_input *input = thread->queue->input;
1782     struct thread *win_thread;
1783     struct list *ptr;
1784     user_handle_t win;
1785     int clear_bits, got_one = 0;
1786     unsigned int msg_code;
1787
1788     ptr = list_head( &input->msg_list );
1789     if (hw_id)
1790     {
1791         while (ptr)
1792         {
1793             struct message *msg = LIST_ENTRY( ptr, struct message, entry );
1794             if (msg->unique_id == hw_id) break;
1795             ptr = list_next( &input->msg_list, ptr );
1796         }
1797         if (!ptr) ptr = list_head( &input->msg_list );
1798         else ptr = list_next( &input->msg_list, ptr );  /* start from the next one */
1799     }
1800
1801     if (ptr == list_head( &input->msg_list ))
1802         clear_bits = QS_KEY | QS_MOUSEMOVE | QS_MOUSEBUTTON;
1803     else
1804         clear_bits = 0;  /* don't clear bits if we don't go through the whole list */
1805
1806     while (ptr)
1807     {
1808         struct message *msg = LIST_ENTRY( ptr, struct message, entry );
1809         struct hardware_msg_data *data = msg->data;
1810
1811         ptr = list_next( &input->msg_list, ptr );
1812         win = find_hardware_message_window( input->desktop, input, msg, &msg_code );
1813         if (!win || !(win_thread = get_window_thread( win )))
1814         {
1815             /* no window at all, remove it */
1816             update_input_key_state( input->desktop, input->keystate, msg );
1817             list_remove( &msg->entry );
1818             free_message( msg );
1819             continue;
1820         }
1821         if (win_thread != thread)
1822         {
1823             if (win_thread->queue->input == input)
1824             {
1825                 /* wake the other thread */
1826                 set_queue_bits( win_thread->queue, get_hardware_msg_bit(msg) );
1827                 got_one = 1;
1828             }
1829             else
1830             {
1831                 /* for another thread input, drop it */
1832                 update_input_key_state( input->desktop, input->keystate, msg );
1833                 list_remove( &msg->entry );
1834                 free_message( msg );
1835             }
1836             release_object( win_thread );
1837             continue;
1838         }
1839         release_object( win_thread );
1840
1841         /* if we already got a message for another thread, or if it doesn't
1842          * match the filter we skip it */
1843         if (got_one || !check_hw_message_filter( win, msg_code, filter_win, first, last ))
1844         {
1845             clear_bits &= ~get_hardware_msg_bit( msg );
1846             continue;
1847         }
1848         /* now we can return it */
1849         if (!msg->unique_id) msg->unique_id = get_unique_id();
1850         reply->type   = MSG_HARDWARE;
1851         reply->win    = win;
1852         reply->msg    = msg_code;
1853         reply->wparam = msg->wparam;
1854         reply->lparam = msg->lparam;
1855         reply->time   = msg->time;
1856
1857         data->hw_id = msg->unique_id;
1858         set_reply_data( msg->data, msg->data_size );
1859         return 1;
1860     }
1861     /* nothing found, clear the hardware queue bits */
1862     clear_queue_bits( thread->queue, clear_bits );
1863     return 0;
1864 }
1865
1866 /* increment (or decrement if 'incr' is negative) the queue paint count */
1867 void inc_queue_paint_count( struct thread *thread, int incr )
1868 {
1869     struct msg_queue *queue = thread->queue;
1870
1871     assert( queue );
1872
1873     if ((queue->paint_count += incr) < 0) queue->paint_count = 0;
1874
1875     if (queue->paint_count)
1876         set_queue_bits( queue, QS_PAINT );
1877     else
1878         clear_queue_bits( queue, QS_PAINT );
1879 }
1880
1881
1882 /* remove all messages and timers belonging to a certain window */
1883 void queue_cleanup_window( struct thread *thread, user_handle_t win )
1884 {
1885     struct msg_queue *queue = thread->queue;
1886     struct list *ptr;
1887     int i;
1888
1889     if (!queue) return;
1890
1891     /* remove timers */
1892
1893     ptr = list_head( &queue->pending_timers );
1894     while (ptr)
1895     {
1896         struct list *next = list_next( &queue->pending_timers, ptr );
1897         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1898         if (timer->win == win) free_timer( queue, timer );
1899         ptr = next;
1900     }
1901     ptr = list_head( &queue->expired_timers );
1902     while (ptr)
1903     {
1904         struct list *next = list_next( &queue->expired_timers, ptr );
1905         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1906         if (timer->win == win) free_timer( queue, timer );
1907         ptr = next;
1908     }
1909
1910     /* remove messages */
1911     for (i = 0; i < NB_MSG_KINDS; i++)
1912     {
1913         struct list *ptr, *next;
1914
1915         LIST_FOR_EACH_SAFE( ptr, next, &queue->msg_list[i] )
1916         {
1917             struct message *msg = LIST_ENTRY( ptr, struct message, entry );
1918             if (msg->win == win)
1919             {
1920                 if (msg->msg == WM_QUIT && !queue->quit_message)
1921                 {
1922                     queue->quit_message = 1;
1923                     queue->exit_code = msg->wparam;
1924                 }
1925                 remove_queue_message( queue, msg, i );
1926             }
1927         }
1928     }
1929
1930     thread_input_cleanup_window( queue, win );
1931 }
1932
1933 /* post a message to a window; used by socket handling */
1934 void post_message( user_handle_t win, unsigned int message, lparam_t wparam, lparam_t lparam )
1935 {
1936     struct message *msg;
1937     struct thread *thread = get_window_thread( win );
1938
1939     if (!thread) return;
1940
1941     if (thread->queue && (msg = mem_alloc( sizeof(*msg) )))
1942     {
1943         msg->type      = MSG_POSTED;
1944         msg->win       = get_user_full_handle( win );
1945         msg->msg       = message;
1946         msg->wparam    = wparam;
1947         msg->lparam    = lparam;
1948         msg->time      = get_tick_count();
1949         msg->result    = NULL;
1950         msg->data      = NULL;
1951         msg->data_size = 0;
1952
1953         list_add_tail( &thread->queue->msg_list[POST_MESSAGE], &msg->entry );
1954         set_queue_bits( thread->queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
1955         if (message == WM_HOTKEY)
1956         {
1957             set_queue_bits( thread->queue, QS_HOTKEY );
1958             thread->queue->hotkey_count++;
1959         }
1960     }
1961     release_object( thread );
1962 }
1963
1964 /* post a win event */
1965 void post_win_event( struct thread *thread, unsigned int event,
1966                      user_handle_t win, unsigned int object_id,
1967                      unsigned int child_id, client_ptr_t hook_proc,
1968                      const WCHAR *module, data_size_t module_size,
1969                      user_handle_t hook)
1970 {
1971     struct message *msg;
1972
1973     if (thread->queue && (msg = mem_alloc( sizeof(*msg) )))
1974     {
1975         struct winevent_msg_data *data;
1976
1977         msg->type      = MSG_WINEVENT;
1978         msg->win       = get_user_full_handle( win );
1979         msg->msg       = event;
1980         msg->wparam    = object_id;
1981         msg->lparam    = child_id;
1982         msg->time      = get_tick_count();
1983         msg->result    = NULL;
1984
1985         if ((data = malloc( sizeof(*data) + module_size )))
1986         {
1987             data->hook = hook;
1988             data->tid  = get_thread_id( current );
1989             data->hook_proc = hook_proc;
1990             memcpy( data + 1, module, module_size );
1991
1992             msg->data = data;
1993             msg->data_size = sizeof(*data) + module_size;
1994
1995             if (debug_level > 1)
1996                 fprintf( stderr, "post_win_event: tid %04x event %04x win %08x object_id %d child_id %d\n",
1997                          get_thread_id(thread), event, win, object_id, child_id );
1998             list_add_tail( &thread->queue->msg_list[SEND_MESSAGE], &msg->entry );
1999             set_queue_bits( thread->queue, QS_SENDMESSAGE );
2000         }
2001         else
2002             free( msg );
2003     }
2004 }
2005
2006 /* free all hotkeys on a desktop, optionally filtering by window */
2007 void free_hotkeys( struct desktop *desktop, user_handle_t window )
2008 {
2009     struct hotkey *hotkey, *hotkey2;
2010
2011     LIST_FOR_EACH_ENTRY_SAFE( hotkey, hotkey2, &desktop->hotkeys, struct hotkey, entry )
2012     {
2013         if (!window || hotkey->win == window)
2014         {
2015             list_remove( &hotkey->entry );
2016             free( hotkey );
2017         }
2018     }
2019 }
2020
2021
2022 /* check if the thread owning the window is hung */
2023 DECL_HANDLER(is_window_hung)
2024 {
2025     struct thread *thread;
2026
2027     thread = get_window_thread( req->win );
2028     if (thread)
2029     {
2030         reply->is_hung = is_queue_hung( thread->queue );
2031         release_object( thread );
2032     }
2033     else reply->is_hung = 0;
2034 }
2035
2036
2037 /* get the message queue of the current thread */
2038 DECL_HANDLER(get_msg_queue)
2039 {
2040     struct msg_queue *queue = get_current_queue();
2041
2042     reply->handle = 0;
2043     if (queue) reply->handle = alloc_handle( current->process, queue, SYNCHRONIZE, 0 );
2044 }
2045
2046
2047 /* set the file descriptor associated to the current thread queue */
2048 DECL_HANDLER(set_queue_fd)
2049 {
2050     struct msg_queue *queue = get_current_queue();
2051     struct file *file;
2052     int unix_fd;
2053
2054     if (queue->fd)  /* fd can only be set once */
2055     {
2056         set_error( STATUS_ACCESS_DENIED );
2057         return;
2058     }
2059     if (!(file = get_file_obj( current->process, req->handle, SYNCHRONIZE ))) return;
2060
2061     if ((unix_fd = get_file_unix_fd( file )) != -1)
2062     {
2063         if ((unix_fd = dup( unix_fd )) != -1)
2064             queue->fd = create_anonymous_fd( &msg_queue_fd_ops, unix_fd, &queue->obj, 0 );
2065         else
2066             file_set_error();
2067     }
2068     release_object( file );
2069 }
2070
2071
2072 /* set the current message queue wakeup mask */
2073 DECL_HANDLER(set_queue_mask)
2074 {
2075     struct msg_queue *queue = get_current_queue();
2076
2077     if (queue)
2078     {
2079         queue->wake_mask    = req->wake_mask;
2080         queue->changed_mask = req->changed_mask;
2081         reply->wake_bits    = queue->wake_bits;
2082         reply->changed_bits = queue->changed_bits;
2083         if (is_signaled( queue ))
2084         {
2085             /* if skip wait is set, do what would have been done in the subsequent wait */
2086             if (req->skip_wait) msg_queue_satisfied( &queue->obj, current );
2087             else wake_up( &queue->obj, 0 );
2088         }
2089     }
2090 }
2091
2092
2093 /* get the current message queue status */
2094 DECL_HANDLER(get_queue_status)
2095 {
2096     struct msg_queue *queue = current->queue;
2097     if (queue)
2098     {
2099         reply->wake_bits    = queue->wake_bits;
2100         reply->changed_bits = queue->changed_bits;
2101         if (req->clear) queue->changed_bits = 0;
2102     }
2103     else reply->wake_bits = reply->changed_bits = 0;
2104 }
2105
2106
2107 /* send a message to a thread queue */
2108 DECL_HANDLER(send_message)
2109 {
2110     struct message *msg;
2111     struct msg_queue *send_queue = get_current_queue();
2112     struct msg_queue *recv_queue = NULL;
2113     struct thread *thread = NULL;
2114
2115     if (!(thread = get_thread_from_id( req->id ))) return;
2116
2117     if (!(recv_queue = thread->queue))
2118     {
2119         set_error( STATUS_INVALID_PARAMETER );
2120         release_object( thread );
2121         return;
2122     }
2123     if ((req->flags & SEND_MSG_ABORT_IF_HUNG) && is_queue_hung(recv_queue))
2124     {
2125         set_error( STATUS_TIMEOUT );
2126         release_object( thread );
2127         return;
2128     }
2129
2130     if ((msg = mem_alloc( sizeof(*msg) )))
2131     {
2132         msg->type      = req->type;
2133         msg->win       = get_user_full_handle( req->win );
2134         msg->msg       = req->msg;
2135         msg->wparam    = req->wparam;
2136         msg->lparam    = req->lparam;
2137         msg->time      = get_tick_count();
2138         msg->result    = NULL;
2139         msg->data      = NULL;
2140         msg->data_size = get_req_data_size();
2141
2142         if (msg->data_size && !(msg->data = memdup( get_req_data(), msg->data_size )))
2143         {
2144             free( msg );
2145             release_object( thread );
2146             return;
2147         }
2148
2149         switch(msg->type)
2150         {
2151         case MSG_OTHER_PROCESS:
2152         case MSG_ASCII:
2153         case MSG_UNICODE:
2154         case MSG_CALLBACK:
2155             if (!(msg->result = alloc_message_result( send_queue, recv_queue, msg, req->timeout )))
2156             {
2157                 free_message( msg );
2158                 break;
2159             }
2160             /* fall through */
2161         case MSG_NOTIFY:
2162             list_add_tail( &recv_queue->msg_list[SEND_MESSAGE], &msg->entry );
2163             set_queue_bits( recv_queue, QS_SENDMESSAGE );
2164             break;
2165         case MSG_POSTED:
2166             list_add_tail( &recv_queue->msg_list[POST_MESSAGE], &msg->entry );
2167             set_queue_bits( recv_queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
2168             if (msg->msg == WM_HOTKEY)
2169             {
2170                 set_queue_bits( recv_queue, QS_HOTKEY );
2171                 recv_queue->hotkey_count++;
2172             }
2173             break;
2174         case MSG_HARDWARE:  /* should use send_hardware_message instead */
2175         case MSG_CALLBACK_RESULT:  /* cannot send this one */
2176         case MSG_HOOK_LL:  /* generated internally */
2177         default:
2178             set_error( STATUS_INVALID_PARAMETER );
2179             free( msg );
2180             break;
2181         }
2182     }
2183     release_object( thread );
2184 }
2185
2186 /* send a hardware message to a thread queue */
2187 DECL_HANDLER(send_hardware_message)
2188 {
2189     struct thread *thread = NULL;
2190     struct desktop *desktop;
2191     struct msg_queue *sender = get_current_queue();
2192     data_size_t size = min( 256, get_reply_max_size() );
2193
2194     if (!(desktop = get_thread_desktop( current, 0 ))) return;
2195
2196     if (req->win)
2197     {
2198         if (!(thread = get_window_thread( req->win ))) return;
2199         if (desktop != thread->queue->input->desktop)
2200         {
2201             /* don't allow queuing events to a different desktop */
2202             release_object( desktop );
2203             return;
2204         }
2205     }
2206
2207     reply->prev_x = desktop->cursor.x;
2208     reply->prev_y = desktop->cursor.y;
2209
2210     switch (req->input.type)
2211     {
2212     case INPUT_MOUSE:
2213         reply->wait = queue_mouse_message( desktop, req->win, &req->input, req->flags, sender );
2214         break;
2215     case INPUT_KEYBOARD:
2216         reply->wait = queue_keyboard_message( desktop, req->win, &req->input, req->flags, sender );
2217         break;
2218     case INPUT_HARDWARE:
2219         queue_custom_hardware_message( desktop, req->win, &req->input );
2220         break;
2221     default:
2222         set_error( STATUS_INVALID_PARAMETER );
2223     }
2224     if (thread) release_object( thread );
2225
2226     reply->new_x = desktop->cursor.x;
2227     reply->new_y = desktop->cursor.y;
2228     set_reply_data( desktop->keystate, size );
2229     release_object( desktop );
2230 }
2231
2232 /* post a quit message to the current queue */
2233 DECL_HANDLER(post_quit_message)
2234 {
2235     struct msg_queue *queue = get_current_queue();
2236
2237     if (!queue)
2238         return;
2239
2240     queue->quit_message = 1;
2241     queue->exit_code = req->exit_code;
2242     set_queue_bits( queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
2243 }
2244
2245 /* get a message from the current queue */
2246 DECL_HANDLER(get_message)
2247 {
2248     struct timer *timer;
2249     struct list *ptr;
2250     struct msg_queue *queue = get_current_queue();
2251     user_handle_t get_win = get_user_full_handle( req->get_win );
2252     unsigned int filter = req->flags >> 16;
2253
2254     reply->active_hooks = get_active_hooks();
2255
2256     if (!queue) return;
2257     queue->last_get_msg = current_time;
2258     if (!filter) filter = QS_ALLINPUT;
2259
2260     /* first check for sent messages */
2261     if ((ptr = list_head( &queue->msg_list[SEND_MESSAGE] )))
2262     {
2263         struct message *msg = LIST_ENTRY( ptr, struct message, entry );
2264         receive_message( queue, msg, reply );
2265         return;
2266     }
2267
2268     /* clear changed bits so we can wait on them if we don't find a message */
2269     if (filter & QS_POSTMESSAGE)
2270     {
2271         queue->changed_bits &= ~(QS_POSTMESSAGE | QS_HOTKEY | QS_TIMER);
2272         if (req->get_first == 0 && req->get_last == ~0U) queue->changed_bits &= ~QS_ALLPOSTMESSAGE;
2273     }
2274     if (filter & QS_INPUT) queue->changed_bits &= ~QS_INPUT;
2275     if (filter & QS_PAINT) queue->changed_bits &= ~QS_PAINT;
2276
2277     /* then check for posted messages */
2278     if ((filter & QS_POSTMESSAGE) &&
2279         get_posted_message( queue, get_win, req->get_first, req->get_last, req->flags, reply ))
2280         return;
2281
2282     if ((filter & QS_HOTKEY) && queue->hotkey_count &&
2283         req->get_first <= WM_HOTKEY && req->get_last >= WM_HOTKEY &&
2284         get_posted_message( queue, get_win, WM_HOTKEY, WM_HOTKEY, req->flags, reply ))
2285         return;
2286
2287     /* only check for quit messages if not posted messages pending.
2288      * note: the quit message isn't filtered */
2289     if (get_quit_message( queue, req->flags, reply ))
2290         return;
2291
2292     /* then check for any raw hardware message */
2293     if ((filter & QS_INPUT) &&
2294         filter_contains_hw_range( req->get_first, req->get_last ) &&
2295         get_hardware_message( current, req->hw_id, get_win, req->get_first, req->get_last, reply ))
2296         return;
2297
2298     /* now check for WM_PAINT */
2299     if ((filter & QS_PAINT) &&
2300         queue->paint_count &&
2301         check_msg_filter( WM_PAINT, req->get_first, req->get_last ) &&
2302         (reply->win = find_window_to_repaint( get_win, current )))
2303     {
2304         reply->type   = MSG_POSTED;
2305         reply->msg    = WM_PAINT;
2306         reply->wparam = 0;
2307         reply->lparam = 0;
2308         reply->time   = get_tick_count();
2309         return;
2310     }
2311
2312     /* now check for timer */
2313     if ((filter & QS_TIMER) &&
2314         (timer = find_expired_timer( queue, get_win, req->get_first,
2315                                      req->get_last, (req->flags & PM_REMOVE) )))
2316     {
2317         reply->type   = MSG_POSTED;
2318         reply->win    = timer->win;
2319         reply->msg    = timer->msg;
2320         reply->wparam = timer->id;
2321         reply->lparam = timer->lparam;
2322         reply->time   = get_tick_count();
2323         if (!(req->flags & PM_NOYIELD) && current->process->idle_event)
2324             set_event( current->process->idle_event );
2325         return;
2326     }
2327
2328     if (get_win == -1 && current->process->idle_event) set_event( current->process->idle_event );
2329     queue->wake_mask = req->wake_mask;
2330     queue->changed_mask = req->changed_mask;
2331     set_error( STATUS_PENDING );  /* FIXME */
2332 }
2333
2334
2335 /* reply to a sent message */
2336 DECL_HANDLER(reply_message)
2337 {
2338     if (!current->queue) set_error( STATUS_ACCESS_DENIED );
2339     else if (current->queue->recv_result)
2340         reply_message( current->queue, req->result, 0, req->remove,
2341                        get_req_data(), get_req_data_size() );
2342 }
2343
2344
2345 /* accept the current hardware message */
2346 DECL_HANDLER(accept_hardware_message)
2347 {
2348     if (current->queue)
2349         release_hardware_message( current->queue, req->hw_id, req->remove, req->new_win );
2350     else
2351         set_error( STATUS_ACCESS_DENIED );
2352 }
2353
2354
2355 /* retrieve the reply for the last message sent */
2356 DECL_HANDLER(get_message_reply)
2357 {
2358     struct message_result *result;
2359     struct list *entry;
2360     struct msg_queue *queue = current->queue;
2361
2362     if (queue)
2363     {
2364         set_error( STATUS_PENDING );
2365         reply->result = 0;
2366
2367         if (!(entry = list_head( &queue->send_result ))) return;  /* no reply ready */
2368
2369         result = LIST_ENTRY( entry, struct message_result, sender_entry );
2370         if (result->replied || req->cancel)
2371         {
2372             if (result->replied)
2373             {
2374                 reply->result = result->result;
2375                 set_error( result->error );
2376                 if (result->data)
2377                 {
2378                     data_size_t data_len = min( result->data_size, get_reply_max_size() );
2379                     set_reply_data_ptr( result->data, data_len );
2380                     result->data = NULL;
2381                     result->data_size = 0;
2382                 }
2383             }
2384             remove_result_from_sender( result );
2385
2386             entry = list_head( &queue->send_result );
2387             if (!entry) clear_queue_bits( queue, QS_SMRESULT );
2388             else
2389             {
2390                 result = LIST_ENTRY( entry, struct message_result, sender_entry );
2391                 if (!result->replied) clear_queue_bits( queue, QS_SMRESULT );
2392             }
2393         }
2394     }
2395     else set_error( STATUS_ACCESS_DENIED );
2396 }
2397
2398
2399 /* set a window timer */
2400 DECL_HANDLER(set_win_timer)
2401 {
2402     struct timer *timer;
2403     struct msg_queue *queue;
2404     struct thread *thread = NULL;
2405     user_handle_t win = 0;
2406     lparam_t id = req->id;
2407
2408     if (req->win)
2409     {
2410         if (!(win = get_user_full_handle( req->win )) || !(thread = get_window_thread( win )))
2411         {
2412             set_error( STATUS_INVALID_HANDLE );
2413             return;
2414         }
2415         if (thread->process != current->process)
2416         {
2417             release_object( thread );
2418             set_error( STATUS_ACCESS_DENIED );
2419             return;
2420         }
2421         queue = thread->queue;
2422         /* remove it if it existed already */
2423         if ((timer = find_timer( queue, win, req->msg, id ))) free_timer( queue, timer );
2424     }
2425     else
2426     {
2427         queue = get_current_queue();
2428         /* look for a timer with this id */
2429         if (id && (timer = find_timer( queue, 0, req->msg, id )))
2430         {
2431             /* free and reuse id */
2432             free_timer( queue, timer );
2433         }
2434         else
2435         {
2436             /* find a free id for it */
2437             do
2438             {
2439                 id = queue->next_timer_id;
2440                 if (--queue->next_timer_id <= 0x100) queue->next_timer_id = 0x7fff;
2441             }
2442             while (find_timer( queue, 0, req->msg, id ));
2443         }
2444     }
2445
2446     if ((timer = set_timer( queue, req->rate )))
2447     {
2448         timer->win    = win;
2449         timer->msg    = req->msg;
2450         timer->id     = id;
2451         timer->lparam = req->lparam;
2452         reply->id     = id;
2453     }
2454     if (thread) release_object( thread );
2455 }
2456
2457 /* kill a window timer */
2458 DECL_HANDLER(kill_win_timer)
2459 {
2460     struct timer *timer;
2461     struct thread *thread;
2462     user_handle_t win = 0;
2463
2464     if (req->win)
2465     {
2466         if (!(win = get_user_full_handle( req->win )) || !(thread = get_window_thread( win )))
2467         {
2468             set_error( STATUS_INVALID_HANDLE );
2469             return;
2470         }
2471         if (thread->process != current->process)
2472         {
2473             release_object( thread );
2474             set_error( STATUS_ACCESS_DENIED );
2475             return;
2476         }
2477     }
2478     else thread = (struct thread *)grab_object( current );
2479
2480     if (thread->queue && (timer = find_timer( thread->queue, win, req->msg, req->id )))
2481         free_timer( thread->queue, timer );
2482     else
2483         set_error( STATUS_INVALID_PARAMETER );
2484
2485     release_object( thread );
2486 }
2487
2488 DECL_HANDLER(register_hotkey)
2489 {
2490     struct desktop *desktop;
2491     user_handle_t win_handle = req->window;
2492     struct hotkey *hotkey;
2493     struct hotkey *new_hotkey = NULL;
2494     struct thread *thread;
2495     const int modifier_flags = MOD_ALT|MOD_CONTROL|MOD_SHIFT|MOD_WIN;
2496
2497     if (!(desktop = get_thread_desktop( current, 0 ))) return;
2498
2499     if (win_handle)
2500     {
2501         if (!get_user_object_handle( &win_handle, USER_WINDOW ))
2502         {
2503             release_object( desktop );
2504             set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
2505             return;
2506         }
2507
2508         thread = get_window_thread( win_handle );
2509         if (thread) release_object( thread );
2510
2511         if (thread != current)
2512         {
2513             release_object( desktop );
2514             set_win32_error( ERROR_WINDOW_OF_OTHER_THREAD );
2515             return;
2516         }
2517     }
2518
2519     LIST_FOR_EACH_ENTRY( hotkey, &desktop->hotkeys, struct hotkey, entry )
2520     {
2521         if (req->vkey == hotkey->vkey &&
2522             (req->flags & modifier_flags) == (hotkey->flags & modifier_flags))
2523         {
2524             release_object( desktop );
2525             set_win32_error( ERROR_HOTKEY_ALREADY_REGISTERED );
2526             return;
2527         }
2528         if (current->queue == hotkey->queue && win_handle == hotkey->win && req->id == hotkey->id)
2529             new_hotkey = hotkey;
2530     }
2531
2532     if (new_hotkey)
2533     {
2534         reply->replaced = 1;
2535         reply->flags    = new_hotkey->flags;
2536         reply->vkey     = new_hotkey->vkey;
2537     }
2538     else
2539     {
2540         new_hotkey = mem_alloc( sizeof(*new_hotkey) );
2541         if (new_hotkey)
2542         {
2543             list_add_tail( &desktop->hotkeys, &new_hotkey->entry );
2544             new_hotkey->queue  = current->queue;
2545             new_hotkey->win    = win_handle;
2546             new_hotkey->id     = req->id;
2547         }
2548     }
2549
2550     if (new_hotkey)
2551     {
2552         new_hotkey->flags = req->flags;
2553         new_hotkey->vkey  = req->vkey;
2554     }
2555
2556     release_object( desktop );
2557 }
2558
2559 DECL_HANDLER(unregister_hotkey)
2560 {
2561     struct desktop *desktop;
2562     user_handle_t win_handle = req->window;
2563     struct hotkey *hotkey;
2564     struct thread *thread;
2565
2566     if (!(desktop = get_thread_desktop( current, 0 ))) return;
2567
2568     if (win_handle)
2569     {
2570         if (!get_user_object_handle( &win_handle, USER_WINDOW ))
2571         {
2572             release_object( desktop );
2573             set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
2574             return;
2575         }
2576
2577         thread = get_window_thread( win_handle );
2578         if (thread) release_object( thread );
2579
2580         if (thread != current)
2581         {
2582             release_object( desktop );
2583             set_win32_error( ERROR_WINDOW_OF_OTHER_THREAD );
2584             return;
2585         }
2586     }
2587
2588     LIST_FOR_EACH_ENTRY( hotkey, &desktop->hotkeys, struct hotkey, entry )
2589     {
2590         if (current->queue == hotkey->queue && win_handle == hotkey->win && req->id == hotkey->id)
2591             goto found;
2592     }
2593
2594     release_object( desktop );
2595     set_win32_error( ERROR_HOTKEY_NOT_REGISTERED );
2596     return;
2597
2598 found:
2599     reply->flags = hotkey->flags;
2600     reply->vkey  = hotkey->vkey;
2601     list_remove( &hotkey->entry );
2602     free( hotkey );
2603     release_object( desktop );
2604 }
2605
2606 /* attach (or detach) thread inputs */
2607 DECL_HANDLER(attach_thread_input)
2608 {
2609     struct thread *thread_from = get_thread_from_id( req->tid_from );
2610     struct thread *thread_to = get_thread_from_id( req->tid_to );
2611
2612     if (!thread_from || !thread_to)
2613     {
2614         if (thread_from) release_object( thread_from );
2615         if (thread_to) release_object( thread_to );
2616         return;
2617     }
2618     if (thread_from != thread_to)
2619     {
2620         if (req->attach) attach_thread_input( thread_from, thread_to );
2621         else
2622         {
2623             if (thread_from->queue && thread_to->queue &&
2624                 thread_from->queue->input == thread_to->queue->input)
2625                 detach_thread_input( thread_from );
2626             else
2627                 set_error( STATUS_ACCESS_DENIED );
2628         }
2629     }
2630     else set_error( STATUS_ACCESS_DENIED );
2631     release_object( thread_from );
2632     release_object( thread_to );
2633 }
2634
2635
2636 /* get thread input data */
2637 DECL_HANDLER(get_thread_input)
2638 {
2639     struct thread *thread = NULL;
2640     struct desktop *desktop;
2641     struct thread_input *input;
2642
2643     if (req->tid)
2644     {
2645         if (!(thread = get_thread_from_id( req->tid ))) return;
2646         if (!(desktop = get_thread_desktop( thread, 0 )))
2647         {
2648             release_object( thread );
2649             return;
2650         }
2651         input = thread->queue ? thread->queue->input : NULL;
2652     }
2653     else
2654     {
2655         if (!(desktop = get_thread_desktop( current, 0 ))) return;
2656         input = desktop->foreground_input;  /* get the foreground thread info */
2657     }
2658
2659     if (input)
2660     {
2661         reply->focus      = input->focus;
2662         reply->capture    = input->capture;
2663         reply->active     = input->active;
2664         reply->menu_owner = input->menu_owner;
2665         reply->move_size  = input->move_size;
2666         reply->caret      = input->caret;
2667         reply->cursor     = input->cursor;
2668         reply->show_count = input->cursor_count;
2669         reply->rect       = input->caret_rect;
2670     }
2671
2672     /* foreground window is active window of foreground thread */
2673     reply->foreground = desktop->foreground_input ? desktop->foreground_input->active : 0;
2674     if (thread) release_object( thread );
2675     release_object( desktop );
2676 }
2677
2678
2679 /* retrieve queue keyboard state for a given thread */
2680 DECL_HANDLER(get_key_state)
2681 {
2682     struct thread *thread;
2683     struct desktop *desktop;
2684     data_size_t size = min( 256, get_reply_max_size() );
2685
2686     if (!req->tid)  /* get global async key state */
2687     {
2688         if (!(desktop = get_thread_desktop( current, 0 ))) return;
2689         if (req->key >= 0)
2690         {
2691             reply->state = desktop->keystate[req->key & 0xff];
2692             desktop->keystate[req->key & 0xff] &= ~0x40;
2693         }
2694         set_reply_data( desktop->keystate, size );
2695         release_object( desktop );
2696     }
2697     else
2698     {
2699         if (!(thread = get_thread_from_id( req->tid ))) return;
2700         if (thread->queue)
2701         {
2702             if (req->key >= 0) reply->state = thread->queue->input->keystate[req->key & 0xff];
2703             set_reply_data( thread->queue->input->keystate, size );
2704         }
2705         release_object( thread );
2706     }
2707 }
2708
2709
2710 /* set queue keyboard state for a given thread */
2711 DECL_HANDLER(set_key_state)
2712 {
2713     struct thread *thread;
2714     struct desktop *desktop;
2715     data_size_t size = min( 256, get_req_data_size() );
2716
2717     if (!req->tid)  /* set global async key state */
2718     {
2719         if (!(desktop = get_thread_desktop( current, 0 ))) return;
2720         memcpy( desktop->keystate, get_req_data(), size );
2721         release_object( desktop );
2722     }
2723     else
2724     {
2725         if (!(thread = get_thread_from_id( req->tid ))) return;
2726         if (thread->queue) memcpy( thread->queue->input->keystate, get_req_data(), size );
2727         if (req->async && (desktop = get_thread_desktop( thread, 0 )))
2728         {
2729             memcpy( desktop->keystate, get_req_data(), size );
2730             release_object( desktop );
2731         }
2732         release_object( thread );
2733     }
2734 }
2735
2736
2737 /* set the system foreground window */
2738 DECL_HANDLER(set_foreground_window)
2739 {
2740     struct thread *thread = NULL;
2741     struct desktop *desktop;
2742     struct msg_queue *queue = get_current_queue();
2743
2744     if (!(desktop = get_thread_desktop( current, 0 ))) return;
2745     reply->previous = desktop->foreground_input ? desktop->foreground_input->active : 0;
2746     reply->send_msg_old = (reply->previous && desktop->foreground_input != queue->input);
2747     reply->send_msg_new = FALSE;
2748
2749     if (is_top_level_window( req->handle ) &&
2750         ((thread = get_window_thread( req->handle ))) &&
2751         (thread->queue->input->desktop == desktop))
2752     {
2753         set_foreground_input( desktop, thread->queue->input );
2754         reply->send_msg_new = (desktop->foreground_input != queue->input);
2755     }
2756     else set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
2757
2758     if (thread) release_object( thread );
2759     release_object( desktop );
2760 }
2761
2762
2763 /* set the current thread focus window */
2764 DECL_HANDLER(set_focus_window)
2765 {
2766     struct msg_queue *queue = get_current_queue();
2767
2768     reply->previous = 0;
2769     if (queue && check_queue_input_window( queue, req->handle ))
2770     {
2771         reply->previous = queue->input->focus;
2772         queue->input->focus = get_user_full_handle( req->handle );
2773     }
2774 }
2775
2776
2777 /* set the current thread active window */
2778 DECL_HANDLER(set_active_window)
2779 {
2780     struct msg_queue *queue = get_current_queue();
2781
2782     reply->previous = 0;
2783     if (queue && check_queue_input_window( queue, req->handle ))
2784     {
2785         if (!req->handle || make_window_active( req->handle ))
2786         {
2787             reply->previous = queue->input->active;
2788             queue->input->active = get_user_full_handle( req->handle );
2789         }
2790         else set_error( STATUS_INVALID_HANDLE );
2791     }
2792 }
2793
2794
2795 /* set the current thread capture window */
2796 DECL_HANDLER(set_capture_window)
2797 {
2798     struct msg_queue *queue = get_current_queue();
2799
2800     reply->previous = reply->full_handle = 0;
2801     if (queue && check_queue_input_window( queue, req->handle ))
2802     {
2803         struct thread_input *input = queue->input;
2804
2805         /* if in menu mode, reject all requests to change focus, except if the menu bit is set */
2806         if (input->menu_owner && !(req->flags & CAPTURE_MENU))
2807         {
2808             set_error(STATUS_ACCESS_DENIED);
2809             return;
2810         }
2811         reply->previous = input->capture;
2812         input->capture = get_user_full_handle( req->handle );
2813         input->menu_owner = (req->flags & CAPTURE_MENU) ? input->capture : 0;
2814         input->move_size = (req->flags & CAPTURE_MOVESIZE) ? input->capture : 0;
2815         reply->full_handle = input->capture;
2816     }
2817 }
2818
2819
2820 /* Set the current thread caret window */
2821 DECL_HANDLER(set_caret_window)
2822 {
2823     struct msg_queue *queue = get_current_queue();
2824
2825     reply->previous = 0;
2826     if (queue && check_queue_input_window( queue, req->handle ))
2827     {
2828         struct thread_input *input = queue->input;
2829
2830         reply->previous  = input->caret;
2831         reply->old_rect  = input->caret_rect;
2832         reply->old_hide  = input->caret_hide;
2833         reply->old_state = input->caret_state;
2834
2835         set_caret_window( input, get_user_full_handle(req->handle) );
2836         input->caret_rect.right  = input->caret_rect.left + req->width;
2837         input->caret_rect.bottom = input->caret_rect.top + req->height;
2838     }
2839 }
2840
2841
2842 /* Set the current thread caret information */
2843 DECL_HANDLER(set_caret_info)
2844 {
2845     struct msg_queue *queue = get_current_queue();
2846     struct thread_input *input;
2847
2848     if (!queue) return;
2849     input = queue->input;
2850     reply->full_handle = input->caret;
2851     reply->old_rect    = input->caret_rect;
2852     reply->old_hide    = input->caret_hide;
2853     reply->old_state   = input->caret_state;
2854
2855     if (req->handle && get_user_full_handle(req->handle) != input->caret)
2856     {
2857         set_error( STATUS_ACCESS_DENIED );
2858         return;
2859     }
2860     if (req->flags & SET_CARET_POS)
2861     {
2862         input->caret_rect.right  += req->x - input->caret_rect.left;
2863         input->caret_rect.bottom += req->y - input->caret_rect.top;
2864         input->caret_rect.left = req->x;
2865         input->caret_rect.top  = req->y;
2866     }
2867     if (req->flags & SET_CARET_HIDE)
2868     {
2869         input->caret_hide += req->hide;
2870         if (input->caret_hide < 0) input->caret_hide = 0;
2871     }
2872     if (req->flags & SET_CARET_STATE)
2873     {
2874         if (req->state == -1) input->caret_state = !input->caret_state;
2875         else input->caret_state = !!req->state;
2876     }
2877 }
2878
2879
2880 /* get the time of the last input event */
2881 DECL_HANDLER(get_last_input_time)
2882 {
2883     reply->time = last_input_time;
2884 }
2885
2886 /* set/get the current cursor */
2887 DECL_HANDLER(set_cursor)
2888 {
2889     struct msg_queue *queue = get_current_queue();
2890     struct thread_input *input;
2891
2892     if (!queue) return;
2893     input = queue->input;
2894
2895     reply->prev_handle = input->cursor;
2896     reply->prev_count  = input->cursor_count;
2897     reply->prev_x      = input->desktop->cursor.x;
2898     reply->prev_y      = input->desktop->cursor.y;
2899
2900     if (req->flags & SET_CURSOR_HANDLE)
2901     {
2902         if (req->handle && !get_user_object( req->handle, USER_CLIENT ))
2903         {
2904             set_win32_error( ERROR_INVALID_CURSOR_HANDLE );
2905             return;
2906         }
2907         input->cursor = req->handle;
2908     }
2909     if (req->flags & SET_CURSOR_COUNT)
2910     {
2911         queue->cursor_count += req->show_count;
2912         input->cursor_count += req->show_count;
2913     }
2914     if (req->flags & SET_CURSOR_POS)
2915     {
2916         set_cursor_pos( input->desktop, req->x, req->y );
2917     }
2918     if (req->flags & (SET_CURSOR_CLIP | SET_CURSOR_NOCLIP))
2919     {
2920         struct desktop *desktop = input->desktop;
2921
2922         /* only the desktop owner can set the message */
2923         if (req->clip_msg && get_top_window_owner(desktop) == current->process)
2924             desktop->cursor.clip_msg = req->clip_msg;
2925
2926         set_clip_rectangle( desktop, (req->flags & SET_CURSOR_NOCLIP) ? NULL : &req->clip );
2927     }
2928
2929     reply->new_x       = input->desktop->cursor.x;
2930     reply->new_y       = input->desktop->cursor.y;
2931     reply->new_clip    = input->desktop->cursor.clip;
2932     reply->last_change = input->desktop->cursor.last_change;
2933 }