git.oblomov.eu Git - wine/blob - 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        *callback_msg;  /* message to queue for callback */
  62     void                  *data;          /* message reply data */
  63     unsigned int           data_size;     /* size of message reply data */
  64     struct timeout_user   *timeout;       /* result timeout */
  65 };
  66
  67 struct message
  68 {
  69     struct list            entry;     /* entry in message list */
  70     enum message_type      type;      /* message type */
  71     user_handle_t          win;       /* window handle */
  72     unsigned int           msg;       /* message code */
  73     lparam_t               wparam;    /* parameters */
  74     lparam_t               lparam;    /* parameters */
  75     unsigned int           time;      /* message time */
  76     void                  *data;      /* message data for sent messages */
  77     unsigned int           data_size; /* size of message data */
  78     unsigned int           unique_id; /* unique id for nested hw message waits */
  79     struct message_result *result;    /* result in sender queue */
  80 };
  81
  82 struct timer
  83 {
  84     struct list     entry;     /* entry in timer list */
  85     timeout_t       when;      /* next expiration */
  86     unsigned int    rate;      /* timer rate in ms */
  87     user_handle_t   win;       /* window handle */
  88     unsigned int    msg;       /* message to post */
  89     lparam_t        id;        /* timer id */
  90     lparam_t        lparam;    /* lparam for message */
  91 };
  92
  93 struct thread_input
  94 {
  95     struct object          obj;           /* object header */
  96     struct desktop        *desktop;       /* desktop that this thread input belongs to */
  97     user_handle_t          focus;         /* focus window */
  98     user_handle_t          capture;       /* capture window */
  99     user_handle_t          active;        /* active window */
 100     user_handle_t          menu_owner;    /* current menu owner window */
 101     user_handle_t          move_size;     /* current moving/resizing window */
 102     user_handle_t          caret;         /* caret window */
 103     rectangle_t            caret_rect;    /* caret rectangle */
 104     int                    caret_hide;    /* caret hide count */
 105     int                    caret_state;   /* caret on/off state */
 106     struct list            msg_list;      /* list of hardware messages */
 107     unsigned char          keystate[256]; /* state of each key */
 108 };
 109
 110 struct msg_queue
 111 {
 112     struct object          obj;             /* object header */
 113     struct fd             *fd;              /* optional file descriptor to poll */
 114     unsigned int           wake_bits;       /* wakeup bits */
 115     unsigned int           wake_mask;       /* wakeup mask */
 116     unsigned int           changed_bits;    /* changed wakeup bits */
 117     unsigned int           changed_mask;    /* changed wakeup mask */
 118     int                    paint_count;     /* pending paint messages count */
 119     int                    quit_message;    /* is there a pending quit message? */
 120     int                    exit_code;       /* exit code of pending quit message */
 121     struct list            msg_list[NB_MSG_KINDS];  /* lists of messages */
 122     struct list            send_result;     /* stack of sent messages waiting for result */
 123     struct list            callback_result; /* list of callback messages waiting for result */
 124     struct message_result *recv_result;     /* stack of received messages waiting for result */
 125     struct list            pending_timers;  /* list of pending timers */
 126     struct list            expired_timers;  /* list of expired timers */
 127     lparam_t               next_timer_id;   /* id for the next timer with a 0 window */
 128     struct timeout_user   *timeout;         /* timeout for next timer to expire */
 129     struct thread_input   *input;           /* thread input descriptor */
 130     struct hook_table     *hooks;           /* hook table */
 131     timeout_t              last_get_msg;    /* time of last get message call */
 132 };
 133
 134 static void msg_queue_dump( struct object *obj, int verbose );
 135 static int msg_queue_add_queue( struct object *obj, struct wait_queue_entry *entry );
 136 static void msg_queue_remove_queue( struct object *obj, struct wait_queue_entry *entry );
 137 static int msg_queue_signaled( struct object *obj, struct thread *thread );
 138 static int msg_queue_satisfied( struct object *obj, struct thread *thread );
 139 static void msg_queue_destroy( struct object *obj );
 140 static void msg_queue_poll_event( struct fd *fd, int event );
 141 static void thread_input_dump( struct object *obj, int verbose );
 142 static void thread_input_destroy( struct object *obj );
 143 static void timer_callback( void *private );
 144
 145 static const struct object_ops msg_queue_ops =
 146 {
 147     sizeof(struct msg_queue),  /* size */
 148     msg_queue_dump,            /* dump */
 149     no_get_type,               /* get_type */
 150     msg_queue_add_queue,       /* add_queue */
 151     msg_queue_remove_queue,    /* remove_queue */
 152     msg_queue_signaled,        /* signaled */
 153     msg_queue_satisfied,       /* satisfied */
 154     no_signal,                 /* signal */
 155     no_get_fd,                 /* get_fd */
 156     no_map_access,             /* map_access */
 157     default_get_sd,            /* get_sd */
 158     default_set_sd,            /* set_sd */
 159     no_lookup_name,            /* lookup_name */
 160     no_open_file,              /* open_file */
 161     no_close_handle,           /* close_handle */
 162     msg_queue_destroy          /* destroy */
 163 };
 164
 165 static const struct fd_ops msg_queue_fd_ops =
 166 {
 167     NULL,                        /* get_poll_events */
 168     msg_queue_poll_event,        /* poll_event */
 169     NULL,                        /* flush */
 170     NULL,                        /* get_fd_type */
 171     NULL,                        /* ioctl */
 172     NULL,                        /* queue_async */
 173     NULL,                        /* reselect_async */
 174     NULL                         /* cancel async */
 175 };
 176
 177
 178 static const struct object_ops thread_input_ops =
 179 {
 180     sizeof(struct thread_input),  /* size */
 181     thread_input_dump,            /* dump */
 182     no_get_type,                  /* get_type */
 183     no_add_queue,                 /* add_queue */
 184     NULL,                         /* remove_queue */
 185     NULL,                         /* signaled */
 186     NULL,                         /* satisfied */
 187     no_signal,                    /* signal */
 188     no_get_fd,                    /* get_fd */
 189     no_map_access,                /* map_access */
 190     default_get_sd,               /* get_sd */
 191     default_set_sd,               /* set_sd */
 192     no_lookup_name,               /* lookup_name */
 193     no_open_file,                 /* open_file */
 194     no_close_handle,              /* close_handle */
 195     thread_input_destroy          /* destroy */
 196 };
 197
 198 /* pointer to input structure of foreground thread */
 199 static struct thread_input *foreground_input;
 200 static unsigned int last_input_time;
 201
 202 static void free_message( struct message *msg );
 203
 204 /* set the caret window in a given thread input */
 205 static void set_caret_window( struct thread_input *input, user_handle_t win )
 206 {
 207     if (!win || win != input->caret)
 208     {
 209         input->caret_rect.left   = 0;
 210         input->caret_rect.top    = 0;
 211         input->caret_rect.right  = 0;
 212         input->caret_rect.bottom = 0;
 213     }
 214     input->caret             = win;
 215     input->caret_hide        = 1;
 216     input->caret_state       = 0;
 217 }
 218
 219 /* create a thread input object */
 220 static struct thread_input *create_thread_input( struct thread *thread )
 221 {
 222     struct thread_input *input;
 223
 224     if ((input = alloc_object( &thread_input_ops )))
 225     {
 226         input->focus       = 0;
 227         input->capture     = 0;
 228         input->active      = 0;
 229         input->menu_owner  = 0;
 230         input->move_size   = 0;
 231         list_init( &input->msg_list );
 232         set_caret_window( input, 0 );
 233         memset( input->keystate, 0, sizeof(input->keystate) );
 234
 235         if (!(input->desktop = get_thread_desktop( thread, 0 /* FIXME: access rights */ )))
 236         {
 237             release_object( input );
 238             return NULL;
 239         }
 240     }
 241     return input;
 242 }
 243
 244 /* release the thread input data of a given thread */
 245 static inline void release_thread_input( struct thread *thread )
 246 {
 247     struct thread_input *input = thread->queue->input;
 248
 249     if (!input) return;
 250     release_object( input );
 251     thread->queue->input = NULL;
 252 }
 253
 254 /* create a message queue object */
 255 static struct msg_queue *create_msg_queue( struct thread *thread, struct thread_input *input )
 256 {
 257     struct msg_queue *queue;
 258     int i;
 259
 260     if (!input && !(input = create_thread_input( thread ))) return NULL;
 261     if ((queue = alloc_object( &msg_queue_ops )))
 262     {
 263         queue->fd              = NULL;
 264         queue->wake_bits       = 0;
 265         queue->wake_mask       = 0;
 266         queue->changed_bits    = 0;
 267         queue->changed_mask    = 0;
 268         queue->paint_count     = 0;
 269         queue->quit_message    = 0;
 270         queue->recv_result     = NULL;
 271         queue->next_timer_id   = 0x7fff;
 272         queue->timeout         = NULL;
 273         queue->input           = (struct thread_input *)grab_object( input );
 274         queue->hooks           = NULL;
 275         queue->last_get_msg    = current_time;
 276         list_init( &queue->send_result );
 277         list_init( &queue->callback_result );
 278         list_init( &queue->pending_timers );
 279         list_init( &queue->expired_timers );
 280         for (i = 0; i < NB_MSG_KINDS; i++) list_init( &queue->msg_list[i] );
 281
 282         thread->queue = queue;
 283         if (!thread->process->queue)
 284             thread->process->queue = (struct msg_queue *)grab_object( queue );
 285     }
 286     release_object( input );
 287     return queue;
 288 }
 289
 290 /* free the message queue of a thread at thread exit */
 291 void free_msg_queue( struct thread *thread )
 292 {
 293     struct process *process = thread->process;
 294
 295     remove_thread_hooks( thread );
 296     if (!thread->queue) return;
 297     if (process->queue == thread->queue)  /* is it the process main queue? */
 298     {
 299         release_object( process->queue );
 300         process->queue = NULL;
 301     }
 302     release_object( thread->queue );
 303     thread->queue = NULL;
 304 }
 305
 306 /* get the hook table for a given thread */
 307 struct hook_table *get_queue_hooks( struct thread *thread )
 308 {
 309     if (!thread->queue) return NULL;
 310     return thread->queue->hooks;
 311 }
 312
 313 /* set the hook table for a given thread, allocating the queue if needed */
 314 void set_queue_hooks( struct thread *thread, struct hook_table *hooks )
 315 {
 316     struct msg_queue *queue = thread->queue;
 317     if (!queue && !(queue = create_msg_queue( thread, NULL ))) return;
 318     if (queue->hooks) release_object( queue->hooks );
 319     queue->hooks = hooks;
 320 }
 321
 322 /* check the queue status */
 323 static inline int is_signaled( struct msg_queue *queue )
 324 {
 325     return ((queue->wake_bits & queue->wake_mask) || (queue->changed_bits & queue->changed_mask));
 326 }
 327
 328 /* set some queue bits */
 329 static inline void set_queue_bits( struct msg_queue *queue, unsigned int bits )
 330 {
 331     queue->wake_bits |= bits;
 332     queue->changed_bits |= bits;
 333     if (is_signaled( queue )) wake_up( &queue->obj, 0 );
 334 }
 335
 336 /* clear some queue bits */
 337 static inline void clear_queue_bits( struct msg_queue *queue, unsigned int bits )
 338 {
 339     queue->wake_bits &= ~bits;
 340     queue->changed_bits &= ~bits;
 341 }
 342
 343 /* check whether msg is a keyboard message */
 344 static inline int is_keyboard_msg( struct message *msg )
 345 {
 346     return (msg->msg >= WM_KEYFIRST && msg->msg <= WM_KEYLAST);
 347 }
 348
 349 /* check if message is matched by the filter */
 350 static inline int check_msg_filter( unsigned int msg, unsigned int first, unsigned int last )
 351 {
 352     return (msg >= first && msg <= last);
 353 }
 354
 355 /* check whether a message filter contains at least one potential hardware message */
 356 static inline int filter_contains_hw_range( unsigned int first, unsigned int last )
 357 {
 358     /* hardware message ranges are (in numerical order):
 359      *   WM_NCMOUSEFIRST .. WM_NCMOUSELAST
 360      *   WM_KEYFIRST .. WM_KEYLAST
 361      *   WM_MOUSEFIRST .. WM_MOUSELAST
 362      */
 363     if (last < WM_NCMOUSEFIRST) return 0;
 364     if (first > WM_NCMOUSELAST && last < WM_KEYFIRST) return 0;
 365     if (first > WM_KEYLAST && last < WM_MOUSEFIRST) return 0;
 366     if (first > WM_MOUSELAST) return 0;
 367     return 1;
 368 }
 369
 370 /* get the QS_* bit corresponding to a given hardware message */
 371 static inline int get_hardware_msg_bit( struct message *msg )
 372 {
 373     if (msg->msg == WM_MOUSEMOVE || msg->msg == WM_NCMOUSEMOVE) return QS_MOUSEMOVE;
 374     if (is_keyboard_msg( msg )) return QS_KEY;
 375     return QS_MOUSEBUTTON;
 376 }
 377
 378 /* get the current thread queue, creating it if needed */
 379 static inline struct msg_queue *get_current_queue(void)
 380 {
 381     struct msg_queue *queue = current->queue;
 382     if (!queue) queue = create_msg_queue( current, NULL );
 383     return queue;
 384 }
 385
 386 /* get a (pseudo-)unique id to tag hardware messages */
 387 static inline unsigned int get_unique_id(void)
 388 {
 389     static unsigned int id;
 390     if (!++id) id = 1;  /* avoid an id of 0 */
 391     return id;
 392 }
 393
 394 /* try to merge a message with the last in the list; return 1 if successful */
 395 static int merge_message( struct thread_input *input, const struct message *msg )
 396 {
 397     struct message *prev;
 398     struct list *ptr = list_tail( &input->msg_list );
 399
 400     if (!ptr) return 0;
 401     prev = LIST_ENTRY( ptr, struct message, entry );
 402     if (prev->result) return 0;
 403     if (prev->win && msg->win && prev->win != msg->win) return 0;
 404     if (prev->msg != msg->msg) return 0;
 405     if (prev->type != msg->type) return 0;
 406     /* now we can merge it */
 407     prev->wparam  = msg->wparam;
 408     prev->lparam  = msg->lparam;
 409     prev->time    = msg->time;
 410     if (msg->type == MSG_HARDWARE && prev->data && msg->data)
 411     {
 412         struct hardware_msg_data *prev_data = prev->data;
 413         struct hardware_msg_data *msg_data = msg->data;
 414         prev_data->x     = msg_data->x;
 415         prev_data->y     = msg_data->y;
 416         prev_data->info  = msg_data->info;
 417     }
 418     return 1;
 419 }
 420
 421 /* free a result structure */
 422 static void free_result( struct message_result *result )
 423 {
 424     if (result->timeout) remove_timeout_user( result->timeout );
 425     free( result->data );
 426     if (result->callback_msg) free_message( result->callback_msg );
 427     free( result );
 428 }
 429
 430 /* remove the result from the sender list it is on */
 431 static inline void remove_result_from_sender( struct message_result *result )
 432 {
 433     assert( result->sender );
 434
 435     list_remove( &result->sender_entry );
 436     result->sender = NULL;
 437     if (!result->receiver) free_result( result );
 438 }
 439
 440 /* store the message result in the appropriate structure */
 441 static void store_message_result( struct message_result *res, lparam_t result, unsigned int error )
 442 {
 443     res->result  = result;
 444     res->error   = error;
 445     res->replied = 1;
 446     if (res->timeout)
 447     {
 448         remove_timeout_user( res->timeout );
 449         res->timeout = NULL;
 450     }
 451     if (res->sender)
 452     {
 453         if (res->callback_msg)
 454         {
 455             /* queue the callback message in the sender queue */
 456             struct callback_msg_data *data = res->callback_msg->data;
 457             data->result = result;
 458             list_add_tail( &res->sender->msg_list[SEND_MESSAGE], &res->callback_msg->entry );
 459             set_queue_bits( res->sender, QS_SENDMESSAGE );
 460             res->callback_msg = NULL;
 461             remove_result_from_sender( res );
 462         }
 463         else
 464         {
 465             /* wake sender queue if waiting on this result */
 466             if (list_head(&res->sender->send_result) == &res->sender_entry)
 467                 set_queue_bits( res->sender, QS_SMRESULT );
 468         }
 469     }
 470
 471 }
 472
 473 /* free a message when deleting a queue or window */
 474 static void free_message( struct message *msg )
 475 {
 476     struct message_result *result = msg->result;
 477     if (result)
 478     {
 479         result->msg = NULL;
 480         if (result->sender)
 481         {
 482             result->receiver = NULL;
 483             store_message_result( result, 0, STATUS_ACCESS_DENIED /*FIXME*/ );
 484         }
 485         else free_result( result );
 486     }
 487     free( msg->data );
 488     free( msg );
 489 }
 490
 491 /* remove (and free) a message from a message list */
 492 static void remove_queue_message( struct msg_queue *queue, struct message *msg,
 493                                   enum message_kind kind )
 494 {
 495     list_remove( &msg->entry );
 496     switch(kind)
 497     {
 498     case SEND_MESSAGE:
 499         if (list_empty( &queue->msg_list[kind] )) clear_queue_bits( queue, QS_SENDMESSAGE );
 500         break;
 501     case POST_MESSAGE:
 502         if (list_empty( &queue->msg_list[kind] ) && !queue->quit_message)
 503             clear_queue_bits( queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
 504         break;
 505     }
 506     free_message( msg );
 507 }
 508
 509 /* message timed out without getting a reply */
 510 static void result_timeout( void *private )
 511 {
 512     struct message_result *result = private;
 513
 514     assert( !result->replied );
 515
 516     result->timeout = NULL;
 517
 518     if (result->msg)  /* not received yet */
 519     {
 520         struct message *msg = result->msg;
 521
 522         result->msg = NULL;
 523         msg->result = NULL;
 524         remove_queue_message( result->receiver, msg, SEND_MESSAGE );
 525         result->receiver = NULL;
 526         if (!result->sender)
 527         {
 528             free_result( result );
 529             return;
 530         }
 531     }
 532
 533     store_message_result( result, 0, STATUS_TIMEOUT );
 534 }
 535
 536 /* allocate and fill a message result structure */
 537 static struct message_result *alloc_message_result( struct msg_queue *send_queue,
 538                                                     struct msg_queue *recv_queue,
 539                                                     struct message *msg, timeout_t timeout )
 540 {
 541     struct message_result *result = mem_alloc( sizeof(*result) );
 542     if (result)
 543     {
 544         result->msg       = msg;
 545         result->sender    = send_queue;
 546         result->receiver  = recv_queue;
 547         result->replied   = 0;
 548         result->data      = NULL;
 549         result->data_size = 0;
 550         result->timeout   = NULL;
 551
 552         if (msg->type == MSG_CALLBACK)
 553         {
 554             struct message *callback_msg = mem_alloc( sizeof(*callback_msg) );
 555
 556             if (!callback_msg)
 557             {
 558                 free( result );
 559                 return NULL;
 560             }
 561             callback_msg->type      = MSG_CALLBACK_RESULT;
 562             callback_msg->win       = msg->win;
 563             callback_msg->msg       = msg->msg;
 564             callback_msg->wparam    = 0;
 565             callback_msg->lparam    = 0;
 566             callback_msg->time      = get_tick_count();
 567             callback_msg->result    = NULL;
 568             /* steal the data from the original message */
 569             callback_msg->data      = msg->data;
 570             callback_msg->data_size = msg->data_size;
 571             msg->data = NULL;
 572             msg->data_size = 0;
 573
 574             result->callback_msg = callback_msg;
 575             list_add_head( &send_queue->callback_result, &result->sender_entry );
 576         }
 577         else
 578         {
 579             result->callback_msg = NULL;
 580             list_add_head( &send_queue->send_result, &result->sender_entry );
 581         }
 582
 583         if (timeout != TIMEOUT_INFINITE)
 584             result->timeout = add_timeout_user( timeout, result_timeout, result );
 585     }
 586     return result;
 587 }
 588
 589 /* receive a message, removing it from the sent queue */
 590 static void receive_message( struct msg_queue *queue, struct message *msg,
 591                              struct get_message_reply *reply )
 592 {
 593     struct message_result *result = msg->result;
 594
 595     reply->total = msg->data_size;
 596     if (msg->data_size > get_reply_max_size())
 597     {
 598         set_error( STATUS_BUFFER_OVERFLOW );
 599         return;
 600     }
 601     reply->type   = msg->type;
 602     reply->win    = msg->win;
 603     reply->msg    = msg->msg;
 604     reply->wparam = msg->wparam;
 605     reply->lparam = msg->lparam;
 606     reply->time   = msg->time;
 607
 608     if (msg->data) set_reply_data_ptr( msg->data, msg->data_size );
 609
 610     list_remove( &msg->entry );
 611     /* put the result on the receiver result stack */
 612     if (result)
 613     {
 614         result->msg = NULL;
 615         result->recv_next  = queue->recv_result;
 616         queue->recv_result = result;
 617     }
 618     free( msg );
 619     if (list_empty( &queue->msg_list[SEND_MESSAGE] )) clear_queue_bits( queue, QS_SENDMESSAGE );
 620 }
 621
 622 /* set the result of the current received message */
 623 static void reply_message( struct msg_queue *queue, lparam_t result,
 624                            unsigned int error, int remove, const void *data, data_size_t len )
 625 {
 626     struct message_result *res = queue->recv_result;
 627
 628     if (remove)
 629     {
 630         queue->recv_result = res->recv_next;
 631         res->receiver = NULL;
 632         if (!res->sender)  /* no one waiting for it */
 633         {
 634             free_result( res );
 635             return;
 636         }
 637     }
 638     if (!res->replied)
 639     {
 640         if (len && (res->data = memdup( data, len ))) res->data_size = len;
 641         store_message_result( res, result, error );
 642     }
 643 }
 644
 645 static int match_window( user_handle_t win, user_handle_t msg_win )
 646 {
 647     if (!win) return 1;
 648     if (win == (user_handle_t)-1) return !msg_win;
 649     if (msg_win == win) return 1;
 650     return is_child_window( win, msg_win );
 651 }
 652
 653 /* retrieve a posted message */
 654 static int get_posted_message( struct msg_queue *queue, user_handle_t win,
 655                                unsigned int first, unsigned int last, unsigned int flags,
 656                                struct get_message_reply *reply )
 657 {
 658     struct message *msg;
 659
 660     /* check against the filters */
 661     LIST_FOR_EACH_ENTRY( msg, &queue->msg_list[POST_MESSAGE], struct message, entry )
 662     {
 663         if (!match_window( win, msg->win )) continue;
 664         if (!check_msg_filter( msg->msg, first, last )) continue;
 665         goto found; /* found one */
 666     }
 667     return 0;
 668
 669     /* return it to the app */
 670 found:
 671     reply->total = msg->data_size;
 672     if (msg->data_size > get_reply_max_size())
 673     {
 674         set_error( STATUS_BUFFER_OVERFLOW );
 675         return 1;
 676     }
 677     reply->type   = msg->type;
 678     reply->win    = msg->win;
 679     reply->msg    = msg->msg;
 680     reply->wparam = msg->wparam;
 681     reply->lparam = msg->lparam;
 682     reply->time   = msg->time;
 683
 684     if (flags & PM_REMOVE)
 685     {
 686         if (msg->data)
 687         {
 688             set_reply_data_ptr( msg->data, msg->data_size );
 689             msg->data = NULL;
 690             msg->data_size = 0;
 691         }
 692         remove_queue_message( queue, msg, POST_MESSAGE );
 693     }
 694     else if (msg->data) set_reply_data( msg->data, msg->data_size );
 695
 696     return 1;
 697 }
 698
 699 static int get_quit_message( struct msg_queue *queue, unsigned int flags,
 700                              struct get_message_reply *reply )
 701 {
 702     if (queue->quit_message)
 703     {
 704         reply->total  = 0;
 705         reply->type   = MSG_POSTED;
 706         reply->win    = 0;
 707         reply->msg    = WM_QUIT;
 708         reply->wparam = queue->exit_code;
 709         reply->lparam = 0;
 710         reply->time   = get_tick_count();
 711
 712         if (flags & PM_REMOVE)
 713         {
 714             queue->quit_message = 0;
 715             if (list_empty( &queue->msg_list[POST_MESSAGE] ))
 716                 clear_queue_bits( queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
 717         }
 718         return 1;
 719     }
 720     else
 721         return 0;
 722 }
 723
 724 /* empty a message list and free all the messages */
 725 static void empty_msg_list( struct list *list )
 726 {
 727     struct list *ptr;
 728
 729     while ((ptr = list_head( list )) != NULL)
 730     {
 731         struct message *msg = LIST_ENTRY( ptr, struct message, entry );
 732         list_remove( &msg->entry );
 733         free_message( msg );
 734     }
 735 }
 736
 737 /* cleanup all pending results when deleting a queue */
 738 static void cleanup_results( struct msg_queue *queue )
 739 {
 740     struct list *entry;
 741
 742     while ((entry = list_head( &queue->send_result )) != NULL)
 743     {
 744         remove_result_from_sender( LIST_ENTRY( entry, struct message_result, sender_entry ) );
 745     }
 746
 747     while ((entry = list_head( &queue->callback_result )) != NULL)
 748     {
 749         remove_result_from_sender( LIST_ENTRY( entry, struct message_result, sender_entry ) );
 750     }
 751
 752     while (queue->recv_result)
 753         reply_message( queue, 0, STATUS_ACCESS_DENIED /*FIXME*/, 1, NULL, 0 );
 754 }
 755
 756 /* check if the thread owning the queue is hung (not checking for messages) */
 757 static int is_queue_hung( struct msg_queue *queue )
 758 {
 759     struct wait_queue_entry *entry;
 760
 761     if (current_time - queue->last_get_msg <= 5 * TICKS_PER_SEC)
 762         return 0;  /* less than 5 seconds since last get message -> not hung */
 763
 764     LIST_FOR_EACH_ENTRY( entry, &queue->obj.wait_queue, struct wait_queue_entry, entry )
 765     {
 766         if (entry->thread->queue == queue)
 767             return 0;  /* thread is waiting on queue -> not hung */
 768     }
 769     return 1;
 770 }
 771
 772 static int msg_queue_add_queue( struct object *obj, struct wait_queue_entry *entry )
 773 {
 774     struct msg_queue *queue = (struct msg_queue *)obj;
 775     struct process *process = entry->thread->process;
 776
 777     /* a thread can only wait on its own queue */
 778     if (entry->thread->queue != queue)
 779     {
 780         set_error( STATUS_ACCESS_DENIED );
 781         return 0;
 782     }
 783     /* if waiting on the main process queue, set the idle event */
 784     if (process->queue == queue)
 785     {
 786         if (process->idle_event) set_event( process->idle_event );
 787     }
 788     if (queue->fd && list_empty( &obj->wait_queue ))  /* first on the queue */
 789         set_fd_events( queue->fd, POLLIN );
 790     add_queue( obj, entry );
 791     return 1;
 792 }
 793
 794 static void msg_queue_remove_queue(struct object *obj, struct wait_queue_entry *entry )
 795 {
 796     struct msg_queue *queue = (struct msg_queue *)obj;
 797     struct process *process = entry->thread->process;
 798
 799     remove_queue( obj, entry );
 800     if (queue->fd && list_empty( &obj->wait_queue ))  /* last on the queue is gone */
 801         set_fd_events( queue->fd, 0 );
 802
 803     assert( entry->thread->queue == queue );
 804
 805     /* if waiting on the main process queue, reset the idle event */
 806     if (process->queue == queue)
 807     {
 808         if (process->idle_event) reset_event( process->idle_event );
 809     }
 810 }
 811
 812 static void msg_queue_dump( struct object *obj, int verbose )
 813 {
 814     struct msg_queue *queue = (struct msg_queue *)obj;
 815     fprintf( stderr, "Msg queue bits=%x mask=%x\n",
 816              queue->wake_bits, queue->wake_mask );
 817 }
 818
 819 static int msg_queue_signaled( struct object *obj, struct thread *thread )
 820 {
 821     struct msg_queue *queue = (struct msg_queue *)obj;
 822     int ret = 0;
 823
 824     if (queue->fd)
 825     {
 826         if ((ret = check_fd_events( queue->fd, POLLIN )))
 827             /* stop waiting on select() if we are signaled */
 828             set_fd_events( queue->fd, 0 );
 829         else if (!list_empty( &obj->wait_queue ))
 830             /* restart waiting on poll() if we are no longer signaled */
 831             set_fd_events( queue->fd, POLLIN );
 832     }
 833     return ret || is_signaled( queue );
 834 }
 835
 836 static int msg_queue_satisfied( struct object *obj, struct thread *thread )
 837 {
 838     struct msg_queue *queue = (struct msg_queue *)obj;
 839     queue->wake_mask = 0;
 840     queue->changed_mask = 0;
 841     return 0;  /* Not abandoned */
 842 }
 843
 844 static void msg_queue_destroy( struct object *obj )
 845 {
 846     struct msg_queue *queue = (struct msg_queue *)obj;
 847     struct list *ptr;
 848     int i;
 849
 850     cleanup_results( queue );
 851     for (i = 0; i < NB_MSG_KINDS; i++) empty_msg_list( &queue->msg_list[i] );
 852
 853     while ((ptr = list_head( &queue->pending_timers )))
 854     {
 855         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
 856         list_remove( &timer->entry );
 857         free( timer );
 858     }
 859     while ((ptr = list_head( &queue->expired_timers )))
 860     {
 861         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
 862         list_remove( &timer->entry );
 863         free( timer );
 864     }
 865     if (queue->timeout) remove_timeout_user( queue->timeout );
 866     if (queue->input) release_object( queue->input );
 867     if (queue->hooks) release_object( queue->hooks );
 868     if (queue->fd) release_object( queue->fd );
 869 }
 870
 871 static void msg_queue_poll_event( struct fd *fd, int event )
 872 {
 873     struct msg_queue *queue = get_fd_user( fd );
 874     assert( queue->obj.ops == &msg_queue_ops );
 875
 876     if (event & (POLLERR | POLLHUP)) set_fd_events( fd, -1 );
 877     else set_fd_events( queue->fd, 0 );
 878     wake_up( &queue->obj, 0 );
 879 }
 880
 881 static void thread_input_dump( struct object *obj, int verbose )
 882 {
 883     struct thread_input *input = (struct thread_input *)obj;
 884     fprintf( stderr, "Thread input focus=%08x capture=%08x active=%08x\n",
 885              input->focus, input->capture, input->active );
 886 }
 887
 888 static void thread_input_destroy( struct object *obj )
 889 {
 890     struct thread_input *input = (struct thread_input *)obj;
 891
 892     if (foreground_input == input) foreground_input = NULL;
 893     empty_msg_list( &input->msg_list );
 894     if (input->desktop) release_object( input->desktop );
 895 }
 896
 897 /* fix the thread input data when a window is destroyed */
 898 static inline void thread_input_cleanup_window( struct msg_queue *queue, user_handle_t window )
 899 {
 900     struct thread_input *input = queue->input;
 901
 902     if (window == input->focus) input->focus = 0;
 903     if (window == input->capture) input->capture = 0;
 904     if (window == input->active) input->active = 0;
 905     if (window == input->menu_owner) input->menu_owner = 0;
 906     if (window == input->move_size) input->move_size = 0;
 907     if (window == input->caret) set_caret_window( input, 0 );
 908 }
 909
 910 /* check if the specified window can be set in the input data of a given queue */
 911 static int check_queue_input_window( struct msg_queue *queue, user_handle_t window )
 912 {
 913     struct thread *thread;
 914     int ret = 0;
 915
 916     if (!window) return 1;  /* we can always clear the data */
 917
 918     if ((thread = get_window_thread( window )))
 919     {
 920         ret = (queue->input == thread->queue->input);
 921         if (!ret) set_error( STATUS_ACCESS_DENIED );
 922         release_object( thread );
 923     }
 924     else set_error( STATUS_INVALID_HANDLE );
 925
 926     return ret;
 927 }
 928
 929 /* make sure the specified thread has a queue */
 930 int init_thread_queue( struct thread *thread )
 931 {
 932     if (thread->queue) return 1;
 933     return (create_msg_queue( thread, NULL ) != NULL);
 934 }
 935
 936 /* attach two thread input data structures */
 937 int attach_thread_input( struct thread *thread_from, struct thread *thread_to )
 938 {
 939     struct desktop *desktop;
 940     struct thread_input *input;
 941
 942     if (!thread_to->queue && !(thread_to->queue = create_msg_queue( thread_to, NULL ))) return 0;
 943     if (!(desktop = get_thread_desktop( thread_from, 0 ))) return 0;
 944     input = (struct thread_input *)grab_object( thread_to->queue->input );
 945     if (input->desktop != desktop)
 946     {
 947         set_error( STATUS_ACCESS_DENIED );
 948         release_object( input );
 949         release_object( desktop );
 950         return 0;
 951     }
 952     release_object( desktop );
 953
 954     if (thread_from->queue)
 955     {
 956         release_thread_input( thread_from );
 957         thread_from->queue->input = input;
 958     }
 959     else
 960     {
 961         if (!(thread_from->queue = create_msg_queue( thread_from, input ))) return 0;
 962     }
 963     memset( input->keystate, 0, sizeof(input->keystate) );
 964     return 1;
 965 }
 966
 967 /* detach two thread input data structures */
 968 void detach_thread_input( struct thread *thread_from )
 969 {
 970     struct thread_input *input;
 971
 972     if ((input = create_thread_input( thread_from )))
 973     {
 974         release_thread_input( thread_from );
 975         thread_from->queue->input = input;
 976     }
 977 }
 978
 979
 980 /* set the next timer to expire */
 981 static void set_next_timer( struct msg_queue *queue )
 982 {
 983     struct list *ptr;
 984
 985     if (queue->timeout)
 986     {
 987         remove_timeout_user( queue->timeout );
 988         queue->timeout = NULL;
 989     }
 990     if ((ptr = list_head( &queue->pending_timers )))
 991     {
 992         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
 993         queue->timeout = add_timeout_user( timer->when, timer_callback, queue );
 994     }
 995     /* set/clear QS_TIMER bit */
 996     if (list_empty( &queue->expired_timers ))
 997         clear_queue_bits( queue, QS_TIMER );
 998     else
 999         set_queue_bits( queue, QS_TIMER );
1000 }
1001
1002 /* find a timer from its window and id */
1003 static struct timer *find_timer( struct msg_queue *queue, user_handle_t win,
1004                                  unsigned int msg, lparam_t id )
1005 {
1006     struct list *ptr;
1007
1008     /* we need to search both lists */
1009
1010     LIST_FOR_EACH( ptr, &queue->pending_timers )
1011     {
1012         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1013         if (timer->win == win && timer->msg == msg && timer->id == id) return timer;
1014     }
1015     LIST_FOR_EACH( ptr, &queue->expired_timers )
1016     {
1017         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1018         if (timer->win == win && timer->msg == msg && timer->id == id) return timer;
1019     }
1020     return NULL;
1021 }
1022
1023 /* callback for the next timer expiration */
1024 static void timer_callback( void *private )
1025 {
1026     struct msg_queue *queue = private;
1027     struct list *ptr;
1028
1029     queue->timeout = NULL;
1030     /* move on to the next timer */
1031     ptr = list_head( &queue->pending_timers );
1032     list_remove( ptr );
1033     list_add_tail( &queue->expired_timers, ptr );
1034     set_next_timer( queue );
1035 }
1036
1037 /* link a timer at its rightful place in the queue list */
1038 static void link_timer( struct msg_queue *queue, struct timer *timer )
1039 {
1040     struct list *ptr;
1041
1042     for (ptr = queue->pending_timers.next; ptr != &queue->pending_timers; ptr = ptr->next)
1043     {
1044         struct timer *t = LIST_ENTRY( ptr, struct timer, entry );
1045         if (t->when >= timer->when) break;
1046     }
1047     list_add_before( ptr, &timer->entry );
1048 }
1049
1050 /* remove a timer from the queue timer list and free it */
1051 static void free_timer( struct msg_queue *queue, struct timer *timer )
1052 {
1053     list_remove( &timer->entry );
1054     free( timer );
1055     set_next_timer( queue );
1056 }
1057
1058 /* restart an expired timer */
1059 static void restart_timer( struct msg_queue *queue, struct timer *timer )
1060 {
1061     list_remove( &timer->entry );
1062     while (timer->when <= current_time) timer->when += (timeout_t)timer->rate * 10000;
1063     link_timer( queue, timer );
1064     set_next_timer( queue );
1065 }
1066
1067 /* find an expired timer matching the filtering parameters */
1068 static struct timer *find_expired_timer( struct msg_queue *queue, user_handle_t win,
1069                                          unsigned int get_first, unsigned int get_last,
1070                                          int remove )
1071 {
1072     struct list *ptr;
1073
1074     LIST_FOR_EACH( ptr, &queue->expired_timers )
1075     {
1076         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1077         if (win && timer->win != win) continue;
1078         if (check_msg_filter( timer->msg, get_first, get_last ))
1079         {
1080             if (remove) restart_timer( queue, timer );
1081             return timer;
1082         }
1083     }
1084     return NULL;
1085 }
1086
1087 /* add a timer */
1088 static struct timer *set_timer( struct msg_queue *queue, unsigned int rate )
1089 {
1090     struct timer *timer = mem_alloc( sizeof(*timer) );
1091     if (timer)
1092     {
1093         timer->rate = max( rate, 1 );
1094         timer->when = current_time + (timeout_t)timer->rate * 10000;
1095         link_timer( queue, timer );
1096         /* check if we replaced the next timer */
1097         if (list_head( &queue->pending_timers ) == &timer->entry) set_next_timer( queue );
1098     }
1099     return timer;
1100 }
1101
1102 /* change the input key state for a given key */
1103 static void set_input_key_state( struct thread_input *input, unsigned char key, int down )
1104 {
1105     if (down)
1106     {
1107         if (!(input->keystate[key] & 0x80)) input->keystate[key] ^= 0x01;
1108         input->keystate[key] |= 0x80;
1109     }
1110     else input->keystate[key] &= ~0x80;
1111 }
1112
1113 /* update the input key state for a keyboard message */
1114 static void update_input_key_state( struct thread_input *input, const struct message *msg )
1115 {
1116     unsigned char key;
1117     int down = 0;
1118
1119     switch (msg->msg)
1120     {
1121     case WM_LBUTTONDOWN:
1122         down = 1;
1123         /* fall through */
1124     case WM_LBUTTONUP:
1125         set_input_key_state( input, VK_LBUTTON, down );
1126         break;
1127     case WM_MBUTTONDOWN:
1128         down = 1;
1129         /* fall through */
1130     case WM_MBUTTONUP:
1131         set_input_key_state( input, VK_MBUTTON, down );
1132         break;
1133     case WM_RBUTTONDOWN:
1134         down = 1;
1135         /* fall through */
1136     case WM_RBUTTONUP:
1137         set_input_key_state( input, VK_RBUTTON, down );
1138         break;
1139     case WM_XBUTTONDOWN:
1140         down = 1;
1141         /* fall through */
1142     case WM_XBUTTONUP:
1143         if (msg->wparam == XBUTTON1) set_input_key_state( input, VK_XBUTTON1, down );
1144         else if (msg->wparam == XBUTTON2) set_input_key_state( input, VK_XBUTTON2, down );
1145         break;
1146     case WM_KEYDOWN:
1147     case WM_SYSKEYDOWN:
1148         down = 1;
1149         /* fall through */
1150     case WM_KEYUP:
1151     case WM_SYSKEYUP:
1152         key = (unsigned char)msg->wparam;
1153         set_input_key_state( input, key, down );
1154         switch(key)
1155         {
1156         case VK_LCONTROL:
1157         case VK_RCONTROL:
1158             down = (input->keystate[VK_LCONTROL] | input->keystate[VK_RCONTROL]) & 0x80;
1159             set_input_key_state( input, VK_CONTROL, down );
1160             break;
1161         case VK_LMENU:
1162         case VK_RMENU:
1163             down = (input->keystate[VK_LMENU] | input->keystate[VK_RMENU]) & 0x80;
1164             set_input_key_state( input, VK_MENU, down );
1165             break;
1166         case VK_LSHIFT:
1167         case VK_RSHIFT:
1168             down = (input->keystate[VK_LSHIFT] | input->keystate[VK_RSHIFT]) & 0x80;
1169             set_input_key_state( input, VK_SHIFT, down );
1170             break;
1171         }
1172         break;
1173     }
1174 }
1175
1176 /* release the hardware message currently being processed by the given thread */
1177 static void release_hardware_message( struct msg_queue *queue, unsigned int hw_id,
1178                                       int remove, user_handle_t new_win )
1179 {
1180     struct thread_input *input = queue->input;
1181     struct message *msg;
1182
1183     LIST_FOR_EACH_ENTRY( msg, &input->msg_list, struct message, entry )
1184     {
1185         if (msg->unique_id == hw_id) break;
1186     }
1187     if (&msg->entry == &input->msg_list) return;  /* not found */
1188
1189     /* clear the queue bit for that message */
1190     if (remove || new_win)
1191     {
1192         struct message *other;
1193         int clr_bit;
1194
1195         clr_bit = get_hardware_msg_bit( msg );
1196         LIST_FOR_EACH_ENTRY( other, &input->msg_list, struct message, entry )
1197         {
1198             if (other != msg && get_hardware_msg_bit( other ) == clr_bit)
1199             {
1200                 clr_bit = 0;
1201                 break;
1202             }
1203         }
1204         if (clr_bit) clear_queue_bits( queue, clr_bit );
1205     }
1206
1207     if (new_win)  /* set the new window */
1208     {
1209         struct thread *owner = get_window_thread( new_win );
1210         if (owner)
1211         {
1212             msg->win = new_win;
1213             if (owner->queue->input != input)
1214             {
1215                 list_remove( &msg->entry );
1216                 if (msg->msg == WM_MOUSEMOVE && merge_message( owner->queue->input, msg ))
1217                 {
1218                     free_message( msg );
1219                     release_object( owner );
1220                     return;
1221                 }
1222                 list_add_tail( &owner->queue->input->msg_list, &msg->entry );
1223             }
1224             set_queue_bits( owner->queue, get_hardware_msg_bit( msg ));
1225             remove = 0;
1226             release_object( owner );
1227         }
1228     }
1229     if (remove)
1230     {
1231         update_input_key_state( input, msg );
1232         list_remove( &msg->entry );
1233         free_message( msg );
1234     }
1235 }
1236
1237 /* find the window that should receive a given hardware message */
1238 static user_handle_t find_hardware_message_window( struct thread_input *input, struct message *msg,
1239                                                    struct hardware_msg_data *data, unsigned int *msg_code )
1240 {
1241     user_handle_t win = 0;
1242
1243     *msg_code = msg->msg;
1244     if (is_keyboard_msg( msg ))
1245     {
1246         if (input && !(win = input->focus))
1247         {
1248             win = input->active;
1249             if (*msg_code < WM_SYSKEYDOWN) *msg_code += WM_SYSKEYDOWN - WM_KEYDOWN;
1250         }
1251     }
1252     else  /* mouse message */
1253     {
1254         if (!input || !(win = input->capture))
1255         {
1256             if (!(win = msg->win) || !is_window_visible( win ))
1257             {
1258                 if (input) win = window_from_point( input->desktop, data->x, data->y );
1259             }
1260         }
1261     }
1262     return win;
1263 }
1264
1265 /* queue a hardware message into a given thread input */
1266 static void queue_hardware_message( struct msg_queue *queue, struct message *msg,
1267                                     struct hardware_msg_data *data )
1268 {
1269     user_handle_t win;
1270     struct thread *thread;
1271     struct thread_input *input = queue ? queue->input : foreground_input;
1272     unsigned int msg_code;
1273
1274     last_input_time = get_tick_count();
1275     win = find_hardware_message_window( input, msg, data, &msg_code );
1276     if (!win || !(thread = get_window_thread(win)))
1277     {
1278         if (input) update_input_key_state( input, msg );
1279         free( msg );
1280         return;
1281     }
1282     input = thread->queue->input;
1283
1284     if (msg->msg == WM_MOUSEMOVE && merge_message( input, msg )) free( msg );
1285     else
1286     {
1287         msg->unique_id = 0;  /* will be set once we return it to the app */
1288         list_add_tail( &input->msg_list, &msg->entry );
1289         set_queue_bits( thread->queue, get_hardware_msg_bit(msg) );
1290     }
1291     release_object( thread );
1292 }
1293
1294 /* check message filter for a hardware message */
1295 static int check_hw_message_filter( user_handle_t win, unsigned int msg_code,
1296                                     user_handle_t filter_win, unsigned int first, unsigned int last )
1297 {
1298     if (msg_code >= WM_KEYFIRST && msg_code <= WM_KEYLAST)
1299     {
1300         /* we can only test the window for a keyboard message since the
1301          * dest window for a mouse message depends on hittest */
1302         if (filter_win && win != filter_win && !is_child_window( filter_win, win ))
1303             return 0;
1304         /* the message code is final for a keyboard message, we can simply check it */
1305         return check_msg_filter( msg_code, first, last );
1306     }
1307     else  /* mouse message */
1308     {
1309         /* we need to check all possible values that the message can have in the end */
1310
1311         if (check_msg_filter( msg_code, first, last )) return 1;
1312         if (msg_code == WM_MOUSEWHEEL) return 0;  /* no other possible value for this one */
1313
1314         /* all other messages can become non-client messages */
1315         if (check_msg_filter( msg_code + (WM_NCMOUSEFIRST - WM_MOUSEFIRST), first, last )) return 1;
1316
1317         /* clicks can become double-clicks or non-client double-clicks */
1318         if (msg_code == WM_LBUTTONDOWN || msg_code == WM_MBUTTONDOWN ||
1319             msg_code == WM_RBUTTONDOWN || msg_code == WM_XBUTTONDOWN)
1320         {
1321             if (check_msg_filter( msg_code + (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN), first, last )) return 1;
1322             if (check_msg_filter( msg_code + (WM_NCLBUTTONDBLCLK - WM_LBUTTONDOWN), first, last )) return 1;
1323         }
1324         return 0;
1325     }
1326 }
1327
1328
1329 /* find a hardware message for the given queue */
1330 static int get_hardware_message( struct thread *thread, unsigned int hw_id, user_handle_t filter_win,
1331                                  unsigned int first, unsigned int last, struct get_message_reply *reply )
1332 {
1333     struct thread_input *input = thread->queue->input;
1334     struct thread *win_thread;
1335     struct list *ptr;
1336     user_handle_t win;
1337     int clear_bits, got_one = 0;
1338     unsigned int msg_code;
1339
1340     ptr = list_head( &input->msg_list );
1341     if (hw_id)
1342     {
1343         while (ptr)
1344         {
1345             struct message *msg = LIST_ENTRY( ptr, struct message, entry );
1346             if (msg->unique_id == hw_id) break;
1347             ptr = list_next( &input->msg_list, ptr );
1348         }
1349         if (!ptr) ptr = list_head( &input->msg_list );
1350         else ptr = list_next( &input->msg_list, ptr );  /* start from the next one */
1351     }
1352
1353     if (ptr == list_head( &input->msg_list ))
1354         clear_bits = QS_KEY | QS_MOUSEMOVE | QS_MOUSEBUTTON;
1355     else
1356         clear_bits = 0;  /* don't clear bits if we don't go through the whole list */
1357
1358     while (ptr)
1359     {
1360         struct message *msg = LIST_ENTRY( ptr, struct message, entry );
1361         struct hardware_msg_data *data = msg->data;
1362
1363         ptr = list_next( &input->msg_list, ptr );
1364         win = find_hardware_message_window( input, msg, data, &msg_code );
1365         if (!win || !(win_thread = get_window_thread( win )))
1366         {
1367             /* no window at all, remove it */
1368             update_input_key_state( input, msg );
1369             list_remove( &msg->entry );
1370             free_message( msg );
1371             continue;
1372         }
1373         if (win_thread != thread)
1374         {
1375             if (win_thread->queue->input == input)
1376             {
1377                 /* wake the other thread */
1378                 set_queue_bits( win_thread->queue, get_hardware_msg_bit(msg) );
1379                 got_one = 1;
1380             }
1381             else
1382             {
1383                 /* for another thread input, drop it */
1384                 update_input_key_state( input, msg );
1385                 list_remove( &msg->entry );
1386                 free_message( msg );
1387             }
1388             release_object( win_thread );
1389             continue;
1390         }
1391         release_object( win_thread );
1392
1393         /* if we already got a message for another thread, or if it doesn't
1394          * match the filter we skip it */
1395         if (got_one || !check_hw_message_filter( win, msg_code, filter_win, first, last ))
1396         {
1397             clear_bits &= ~get_hardware_msg_bit( msg );
1398             continue;
1399         }
1400         /* now we can return it */
1401         if (!msg->unique_id) msg->unique_id = get_unique_id();
1402         reply->type   = MSG_HARDWARE;
1403         reply->win    = win;
1404         reply->msg    = msg_code;
1405         reply->wparam = msg->wparam;
1406         reply->lparam = msg->lparam;
1407         reply->time   = msg->time;
1408
1409         data->hw_id = msg->unique_id;
1410         set_reply_data( msg->data, msg->data_size );
1411         return 1;
1412     }
1413     /* nothing found, clear the hardware queue bits */
1414     clear_queue_bits( thread->queue, clear_bits );
1415     return 0;
1416 }
1417
1418 /* increment (or decrement if 'incr' is negative) the queue paint count */
1419 void inc_queue_paint_count( struct thread *thread, int incr )
1420 {
1421     struct msg_queue *queue = thread->queue;
1422
1423     assert( queue );
1424
1425     if ((queue->paint_count += incr) < 0) queue->paint_count = 0;
1426
1427     if (queue->paint_count)
1428         set_queue_bits( queue, QS_PAINT );
1429     else
1430         clear_queue_bits( queue, QS_PAINT );
1431 }
1432
1433
1434 /* remove all messages and timers belonging to a certain window */
1435 void queue_cleanup_window( struct thread *thread, user_handle_t win )
1436 {
1437     struct msg_queue *queue = thread->queue;
1438     struct list *ptr;
1439     int i;
1440
1441     if (!queue) return;
1442
1443     /* remove timers */
1444
1445     ptr = list_head( &queue->pending_timers );
1446     while (ptr)
1447     {
1448         struct list *next = list_next( &queue->pending_timers, ptr );
1449         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1450         if (timer->win == win) free_timer( queue, timer );
1451         ptr = next;
1452     }
1453     ptr = list_head( &queue->expired_timers );
1454     while (ptr)
1455     {
1456         struct list *next = list_next( &queue->expired_timers, ptr );
1457         struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
1458         if (timer->win == win) free_timer( queue, timer );
1459         ptr = next;
1460     }
1461
1462     /* remove messages */
1463     for (i = 0; i < NB_MSG_KINDS; i++)
1464     {
1465         struct list *ptr, *next;
1466
1467         LIST_FOR_EACH_SAFE( ptr, next, &queue->msg_list[i] )
1468         {
1469             struct message *msg = LIST_ENTRY( ptr, struct message, entry );
1470             if (msg->win == win) remove_queue_message( queue, msg, i );
1471         }
1472     }
1473
1474     thread_input_cleanup_window( queue, win );
1475 }
1476
1477 /* post a message to a window; used by socket handling */
1478 void post_message( user_handle_t win, unsigned int message, lparam_t wparam, lparam_t lparam )
1479 {
1480     struct message *msg;
1481     struct thread *thread = get_window_thread( win );
1482
1483     if (!thread) return;
1484
1485     if (thread->queue && (msg = mem_alloc( sizeof(*msg) )))
1486     {
1487         msg->type      = MSG_POSTED;
1488         msg->win       = get_user_full_handle( win );
1489         msg->msg       = message;
1490         msg->wparam    = wparam;
1491         msg->lparam    = lparam;
1492         msg->time      = get_tick_count();
1493         msg->result    = NULL;
1494         msg->data      = NULL;
1495         msg->data_size = 0;
1496
1497         list_add_tail( &thread->queue->msg_list[POST_MESSAGE], &msg->entry );
1498         set_queue_bits( thread->queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
1499     }
1500     release_object( thread );
1501 }
1502
1503 /* post a win event */
1504 void post_win_event( struct thread *thread, unsigned int event,
1505                      user_handle_t win, unsigned int object_id,
1506                      unsigned int child_id, client_ptr_t hook_proc,
1507                      const WCHAR *module, data_size_t module_size,
1508                      user_handle_t hook)
1509 {
1510     struct message *msg;
1511
1512     if (thread->queue && (msg = mem_alloc( sizeof(*msg) )))
1513     {
1514         struct winevent_msg_data *data;
1515
1516         msg->type      = MSG_WINEVENT;
1517         msg->win       = get_user_full_handle( win );
1518         msg->msg       = event;
1519         msg->wparam    = object_id;
1520         msg->lparam    = child_id;
1521         msg->time      = get_tick_count();
1522         msg->result    = NULL;
1523
1524         if ((data = malloc( sizeof(*data) + module_size )))
1525         {
1526             data->hook = hook;
1527             data->tid  = get_thread_id( current );
1528             data->hook_proc = hook_proc;
1529             memcpy( data + 1, module, module_size );
1530
1531             msg->data = data;
1532             msg->data_size = sizeof(*data) + module_size;
1533
1534             if (debug_level > 1)
1535                 fprintf( stderr, "post_win_event: tid %04x event %04x win %08x object_id %d child_id %d\n",
1536                          get_thread_id(thread), event, win, object_id, child_id );
1537             list_add_tail( &thread->queue->msg_list[SEND_MESSAGE], &msg->entry );
1538             set_queue_bits( thread->queue, QS_SENDMESSAGE );
1539         }
1540         else
1541             free( msg );
1542     }
1543 }
1544
1545
1546 /* check if the thread owning the window is hung */
1547 DECL_HANDLER(is_window_hung)
1548 {
1549     struct thread *thread;
1550
1551     thread = get_window_thread( req->win );
1552     if (thread)
1553     {
1554         reply->is_hung = is_queue_hung( thread->queue );
1555         release_object( thread );
1556     }
1557     else reply->is_hung = 0;
1558 }
1559
1560
1561 /* get the message queue of the current thread */
1562 DECL_HANDLER(get_msg_queue)
1563 {
1564     struct msg_queue *queue = get_current_queue();
1565
1566     reply->handle = 0;
1567     if (queue) reply->handle = alloc_handle( current->process, queue, SYNCHRONIZE, 0 );
1568 }
1569
1570
1571 /* set the file descriptor associated to the current thread queue */
1572 DECL_HANDLER(set_queue_fd)
1573 {
1574     struct msg_queue *queue = get_current_queue();
1575     struct file *file;
1576     int unix_fd;
1577
1578     if (queue->fd)  /* fd can only be set once */
1579     {
1580         set_error( STATUS_ACCESS_DENIED );
1581         return;
1582     }
1583     if (!(file = get_file_obj( current->process, req->handle, SYNCHRONIZE ))) return;
1584
1585     if ((unix_fd = get_file_unix_fd( file )) != -1)
1586     {
1587         if ((unix_fd = dup( unix_fd )) != -1)
1588             queue->fd = create_anonymous_fd( &msg_queue_fd_ops, unix_fd, &queue->obj, 0 );
1589         else
1590             file_set_error();
1591     }
1592     release_object( file );
1593 }
1594
1595
1596 /* set the current message queue wakeup mask */
1597 DECL_HANDLER(set_queue_mask)
1598 {
1599     struct msg_queue *queue = get_current_queue();
1600
1601     if (queue)
1602     {
1603         queue->wake_mask    = req->wake_mask;
1604         queue->changed_mask = req->changed_mask;
1605         reply->wake_bits    = queue->wake_bits;
1606         reply->changed_bits = queue->changed_bits;
1607         if (is_signaled( queue ))
1608         {
1609             /* if skip wait is set, do what would have been done in the subsequent wait */
1610             if (req->skip_wait) msg_queue_satisfied( &queue->obj, current );
1611             else wake_up( &queue->obj, 0 );
1612         }
1613     }
1614 }
1615
1616
1617 /* get the current message queue status */
1618 DECL_HANDLER(get_queue_status)
1619 {
1620     struct msg_queue *queue = current->queue;
1621     if (queue)
1622     {
1623         reply->wake_bits    = queue->wake_bits;
1624         reply->changed_bits = queue->changed_bits;
1625         if (req->clear) queue->changed_bits = 0;
1626     }
1627     else reply->wake_bits = reply->changed_bits = 0;
1628 }
1629
1630
1631 /* send a message to a thread queue */
1632 DECL_HANDLER(send_message)
1633 {
1634     struct message *msg;
1635     struct msg_queue *send_queue = get_current_queue();
1636     struct msg_queue *recv_queue = NULL;
1637     struct thread *thread = NULL;
1638
1639     if (!(thread = get_thread_from_id( req->id ))) return;
1640
1641     if (!(recv_queue = thread->queue))
1642     {
1643         set_error( STATUS_INVALID_PARAMETER );
1644         release_object( thread );
1645         return;
1646     }
1647     if ((req->flags & SEND_MSG_ABORT_IF_HUNG) && is_queue_hung(recv_queue))
1648     {
1649         set_error( STATUS_TIMEOUT );
1650         release_object( thread );
1651         return;
1652     }
1653
1654     if ((msg = mem_alloc( sizeof(*msg) )))
1655     {
1656         msg->type      = req->type;
1657         msg->win       = get_user_full_handle( req->win );
1658         msg->msg       = req->msg;
1659         msg->wparam    = req->wparam;
1660         msg->lparam    = req->lparam;
1661         msg->time      = get_tick_count();
1662         msg->result    = NULL;
1663         msg->data      = NULL;
1664         msg->data_size = get_req_data_size();
1665
1666         if (msg->data_size && !(msg->data = memdup( get_req_data(), msg->data_size )))
1667         {
1668             free( msg );
1669             release_object( thread );
1670             return;
1671         }
1672
1673         switch(msg->type)
1674         {
1675         case MSG_OTHER_PROCESS:
1676         case MSG_ASCII:
1677         case MSG_UNICODE:
1678         case MSG_CALLBACK:
1679             if (!(msg->result = alloc_message_result( send_queue, recv_queue, msg, req->timeout )))
1680             {
1681                 free_message( msg );
1682                 break;
1683             }
1684             /* fall through */
1685         case MSG_NOTIFY:
1686             list_add_tail( &recv_queue->msg_list[SEND_MESSAGE], &msg->entry );
1687             set_queue_bits( recv_queue, QS_SENDMESSAGE );
1688             break;
1689         case MSG_POSTED:
1690             list_add_tail( &recv_queue->msg_list[POST_MESSAGE], &msg->entry );
1691             set_queue_bits( recv_queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
1692             break;
1693         case MSG_HARDWARE:  /* should use send_hardware_message instead */
1694         case MSG_CALLBACK_RESULT:  /* cannot send this one */
1695         default:
1696             set_error( STATUS_INVALID_PARAMETER );
1697             free( msg );
1698             break;
1699         }
1700     }
1701     release_object( thread );
1702 }
1703
1704 /* send a hardware message to a thread queue */
1705 DECL_HANDLER(send_hardware_message)
1706 {
1707     struct message *msg;
1708     struct msg_queue *recv_queue = NULL;
1709     struct thread *thread = NULL;
1710     struct hardware_msg_data *data;
1711
1712     if (req->id)
1713     {
1714         if (!(thread = get_thread_from_id( req->id ))) return;
1715     }
1716
1717     if (thread && !(recv_queue = thread->queue))
1718     {
1719         set_error( STATUS_INVALID_PARAMETER );
1720         release_object( thread );
1721         return;
1722     }
1723
1724     if (!(data = mem_alloc( sizeof(*data) )))
1725     {
1726         if (thread) release_object( thread );
1727         return;
1728     }
1729     memset( data, 0, sizeof(*data) );
1730     data->x    = req->x;
1731     data->y    = req->y;
1732     data->info = req->info;
1733
1734     if ((msg = mem_alloc( sizeof(*msg) )))
1735     {
1736         msg->type      = MSG_HARDWARE;
1737         msg->win       = get_user_full_handle( req->win );
1738         msg->msg       = req->msg;
1739         msg->wparam    = req->wparam;
1740         msg->lparam    = req->lparam;
1741         msg->time      = req->time;
1742         msg->result    = NULL;
1743         msg->data      = data;
1744         msg->data_size = sizeof(*data);
1745         queue_hardware_message( recv_queue, msg, data );
1746     }
1747     else free( data );
1748
1749     if (thread) release_object( thread );
1750 }
1751
1752 /* post a quit message to the current queue */
1753 DECL_HANDLER(post_quit_message)
1754 {
1755     struct msg_queue *queue = get_current_queue();
1756
1757     if (!queue)
1758         return;
1759
1760     queue->quit_message = 1;
1761     queue->exit_code = req->exit_code;
1762     set_queue_bits( queue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE );
1763 }
1764
1765 /* get a message from the current queue */
1766 DECL_HANDLER(get_message)
1767 {
1768     struct timer *timer;
1769     struct list *ptr;
1770     struct msg_queue *queue = get_current_queue();
1771     user_handle_t get_win = get_user_full_handle( req->get_win );
1772     unsigned int filter = req->flags >> 16;
1773
1774     reply->active_hooks = get_active_hooks();
1775
1776     if (!queue) return;
1777     queue->last_get_msg = current_time;
1778     if (!filter) filter = QS_ALLINPUT;
1779
1780     /* first check for sent messages */
1781     if ((ptr = list_head( &queue->msg_list[SEND_MESSAGE] )))
1782     {
1783         struct message *msg = LIST_ENTRY( ptr, struct message, entry );
1784         receive_message( queue, msg, reply );
1785         return;
1786     }
1787
1788     /* clear changed bits so we can wait on them if we don't find a message */
1789     if (filter & QS_POSTMESSAGE)
1790     {
1791         queue->changed_bits &= ~(QS_POSTMESSAGE | QS_HOTKEY | QS_TIMER);
1792         if (req->get_first == 0 && req->get_last == ~0U) queue->changed_bits &= ~QS_ALLPOSTMESSAGE;
1793     }
1794     if (filter & QS_INPUT) queue->changed_bits &= ~QS_INPUT;
1795     if (filter & QS_PAINT) queue->changed_bits &= ~QS_PAINT;
1796
1797     /* then check for posted messages */
1798     if ((filter & QS_POSTMESSAGE) &&
1799         get_posted_message( queue, get_win, req->get_first, req->get_last, req->flags, reply ))
1800         return;
1801
1802     /* only check for quit messages if not posted messages pending.
1803      * note: the quit message isn't filtered */
1804     if (get_quit_message( queue, req->flags, reply ))
1805         return;
1806
1807     /* then check for any raw hardware message */
1808     if ((filter & QS_INPUT) &&
1809         filter_contains_hw_range( req->get_first, req->get_last ) &&
1810         get_hardware_message( current, req->hw_id, get_win, req->get_first, req->get_last, reply ))
1811         return;
1812
1813     /* now check for WM_PAINT */
1814     if ((filter & QS_PAINT) &&
1815         queue->paint_count &&
1816         check_msg_filter( WM_PAINT, req->get_first, req->get_last ) &&
1817         (reply->win = find_window_to_repaint( get_win, current )))
1818     {
1819         reply->type   = MSG_POSTED;
1820         reply->msg    = WM_PAINT;
1821         reply->wparam = 0;
1822         reply->lparam = 0;
1823         reply->time   = get_tick_count();
1824         return;
1825     }
1826
1827     /* now check for timer */
1828     if ((filter & QS_TIMER) &&
1829         (timer = find_expired_timer( queue, get_win, req->get_first,
1830                                      req->get_last, (req->flags & PM_REMOVE) )))
1831     {
1832         reply->type   = MSG_POSTED;
1833         reply->win    = timer->win;
1834         reply->msg    = timer->msg;
1835         reply->wparam = timer->id;
1836         reply->lparam = timer->lparam;
1837         reply->time   = get_tick_count();
1838         return;
1839     }
1840
1841     queue->wake_mask = req->wake_mask;
1842     queue->changed_mask = req->changed_mask;
1843     set_error( STATUS_PENDING );  /* FIXME */
1844 }
1845
1846
1847 /* reply to a sent message */
1848 DECL_HANDLER(reply_message)
1849 {
1850     if (!current->queue) set_error( STATUS_ACCESS_DENIED );
1851     else if (current->queue->recv_result)
1852         reply_message( current->queue, req->result, 0, req->remove,
1853                        get_req_data(), get_req_data_size() );
1854 }
1855
1856
1857 /* accept the current hardware message */
1858 DECL_HANDLER(accept_hardware_message)
1859 {
1860     if (current->queue)
1861         release_hardware_message( current->queue, req->hw_id, req->remove, req->new_win );
1862     else
1863         set_error( STATUS_ACCESS_DENIED );
1864 }
1865
1866
1867 /* retrieve the reply for the last message sent */
1868 DECL_HANDLER(get_message_reply)
1869 {
1870     struct message_result *result;
1871     struct list *entry;
1872     struct msg_queue *queue = current->queue;
1873
1874     if (queue)
1875     {
1876         set_error( STATUS_PENDING );
1877         reply->result = 0;
1878
1879         if (!(entry = list_head( &queue->send_result ))) return;  /* no reply ready */
1880
1881         result = LIST_ENTRY( entry, struct message_result, sender_entry );
1882         if (result->replied || req->cancel)
1883         {
1884             if (result->replied)
1885             {
1886                 reply->result = result->result;
1887                 set_error( result->error );
1888                 if (result->data)
1889                 {
1890                     data_size_t data_len = min( result->data_size, get_reply_max_size() );
1891                     set_reply_data_ptr( result->data, data_len );
1892                     result->data = NULL;
1893                     result->data_size = 0;
1894                 }
1895             }
1896             remove_result_from_sender( result );
1897
1898             entry = list_head( &queue->send_result );
1899             if (!entry) clear_queue_bits( queue, QS_SMRESULT );
1900             else
1901             {
1902                 result = LIST_ENTRY( entry, struct message_result, sender_entry );
1903                 if (!result->replied) clear_queue_bits( queue, QS_SMRESULT );
1904             }
1905         }
1906     }
1907     else set_error( STATUS_ACCESS_DENIED );
1908 }
1909
1910
1911 /* set a window timer */
1912 DECL_HANDLER(set_win_timer)
1913 {
1914     struct timer *timer;
1915     struct msg_queue *queue;
1916     struct thread *thread = NULL;
1917     user_handle_t win = 0;
1918     lparam_t id = req->id;
1919
1920     if (req->win)
1921     {
1922         if (!(win = get_user_full_handle( req->win )) || !(thread = get_window_thread( win )))
1923         {
1924             set_error( STATUS_INVALID_HANDLE );
1925             return;
1926         }
1927         if (thread->process != current->process)
1928         {
1929             release_object( thread );
1930             set_error( STATUS_ACCESS_DENIED );
1931             return;
1932         }
1933         queue = thread->queue;
1934         /* remove it if it existed already */
1935         if ((timer = find_timer( queue, win, req->msg, id ))) free_timer( queue, timer );
1936     }
1937     else
1938     {
1939         queue = get_current_queue();
1940         /* look for a timer with this id */
1941         if (id && (timer = find_timer( queue, 0, req->msg, id )))
1942         {
1943             /* free and reuse id */
1944             free_timer( queue, timer );
1945         }
1946         else
1947         {
1948             /* find a free id for it */
1949             do
1950             {
1951                 id = queue->next_timer_id;
1952                 if (--queue->next_timer_id <= 0x100) queue->next_timer_id = 0x7fff;
1953             }
1954             while (find_timer( queue, 0, req->msg, id ));
1955         }
1956     }
1957
1958     if ((timer = set_timer( queue, req->rate )))
1959     {
1960         timer->win    = win;
1961         timer->msg    = req->msg;
1962         timer->id     = id;
1963         timer->lparam = req->lparam;
1964         reply->id     = id;
1965     }
1966     if (thread) release_object( thread );
1967 }
1968
1969 /* kill a window timer */
1970 DECL_HANDLER(kill_win_timer)
1971 {
1972     struct timer *timer;
1973     struct thread *thread;
1974     user_handle_t win = 0;
1975
1976     if (req->win)
1977     {
1978         if (!(win = get_user_full_handle( req->win )) || !(thread = get_window_thread( win )))
1979         {
1980             set_error( STATUS_INVALID_HANDLE );
1981             return;
1982         }
1983         if (thread->process != current->process)
1984         {
1985             release_object( thread );
1986             set_error( STATUS_ACCESS_DENIED );
1987             return;
1988         }
1989     }
1990     else thread = (struct thread *)grab_object( current );
1991
1992     if (thread->queue && (timer = find_timer( thread->queue, win, req->msg, req->id )))
1993         free_timer( thread->queue, timer );
1994     else
1995         set_error( STATUS_INVALID_PARAMETER );
1996
1997     release_object( thread );
1998 }
1999
2000
2001 /* attach (or detach) thread inputs */
2002 DECL_HANDLER(attach_thread_input)
2003 {
2004     struct thread *thread_from = get_thread_from_id( req->tid_from );
2005     struct thread *thread_to = get_thread_from_id( req->tid_to );
2006
2007     if (!thread_from || !thread_to)
2008     {
2009         if (thread_from) release_object( thread_from );
2010         if (thread_to) release_object( thread_to );
2011         return;
2012     }
2013     if (thread_from != thread_to)
2014     {
2015         if (req->attach) attach_thread_input( thread_from, thread_to );
2016         else
2017         {
2018             if (thread_from->queue && thread_to->queue &&
2019                 thread_from->queue->input == thread_to->queue->input)
2020                 detach_thread_input( thread_from );
2021             else
2022                 set_error( STATUS_ACCESS_DENIED );
2023         }
2024     }
2025     else set_error( STATUS_ACCESS_DENIED );
2026     release_object( thread_from );
2027     release_object( thread_to );
2028 }
2029
2030
2031 /* get thread input data */
2032 DECL_HANDLER(get_thread_input)
2033 {
2034     struct thread *thread = NULL;
2035     struct thread_input *input;
2036
2037     if (req->tid)
2038     {
2039         if (!(thread = get_thread_from_id( req->tid ))) return;
2040         input = thread->queue ? thread->queue->input : NULL;
2041     }
2042     else input = foreground_input;  /* get the foreground thread info */
2043
2044     if (input)
2045     {
2046         reply->focus      = input->focus;
2047         reply->capture    = input->capture;
2048         reply->active     = input->active;
2049         reply->menu_owner = input->menu_owner;
2050         reply->move_size  = input->move_size;
2051         reply->caret      = input->caret;
2052         reply->rect       = input->caret_rect;
2053     }
2054     else
2055     {
2056         reply->focus      = 0;
2057         reply->capture    = 0;
2058         reply->active     = 0;
2059         reply->menu_owner = 0;
2060         reply->move_size  = 0;
2061         reply->caret      = 0;
2062         reply->rect.left = reply->rect.top = reply->rect.right = reply->rect.bottom = 0;
2063     }
2064     /* foreground window is active window of foreground thread */
2065     reply->foreground = foreground_input ? foreground_input->active : 0;
2066     if (thread) release_object( thread );
2067 }
2068
2069
2070 /* retrieve queue keyboard state for a given thread */
2071 DECL_HANDLER(get_key_state)
2072 {
2073     struct thread *thread;
2074     struct thread_input *input;
2075
2076     if (!(thread = get_thread_from_id( req->tid ))) return;
2077     input = thread->queue ? thread->queue->input : NULL;
2078     if (input)
2079     {
2080         if (req->key >= 0) reply->state = input->keystate[req->key & 0xff];
2081         set_reply_data( input->keystate, min( get_reply_max_size(), sizeof(input->keystate) ));
2082     }
2083     release_object( thread );
2084 }
2085
2086
2087 /* set queue keyboard state for a given thread */
2088 DECL_HANDLER(set_key_state)
2089 {
2090     struct thread *thread = NULL;
2091     struct thread_input *input;
2092
2093     if (!(thread = get_thread_from_id( req->tid ))) return;
2094     input = thread->queue ? thread->queue->input : NULL;
2095     if (input)
2096     {
2097         data_size_t size = min( sizeof(input->keystate), get_req_data_size() );
2098         if (size) memcpy( input->keystate, get_req_data(), size );
2099     }
2100     release_object( thread );
2101 }
2102
2103
2104 /* set the system foreground window */
2105 DECL_HANDLER(set_foreground_window)
2106 {
2107     struct thread *thread;
2108     struct msg_queue *queue = get_current_queue();
2109
2110     reply->previous = foreground_input ? foreground_input->active : 0;
2111     reply->send_msg_old = (reply->previous && foreground_input != queue->input);
2112     reply->send_msg_new = FALSE;
2113
2114     if (is_top_level_window( req->handle ) &&
2115         ((thread = get_window_thread( req->handle ))))
2116     {
2117         foreground_input = thread->queue->input;
2118         reply->send_msg_new = (foreground_input != queue->input);
2119         release_object( thread );
2120     }
2121     else set_win32_error( ERROR_INVALID_WINDOW_HANDLE );
2122 }
2123
2124
2125 /* set the current thread focus window */
2126 DECL_HANDLER(set_focus_window)
2127 {
2128     struct msg_queue *queue = get_current_queue();
2129
2130     reply->previous = 0;
2131     if (queue && check_queue_input_window( queue, req->handle ))
2132     {
2133         reply->previous = queue->input->focus;
2134         queue->input->focus = get_user_full_handle( req->handle );
2135     }
2136 }
2137
2138
2139 /* set the current thread active window */
2140 DECL_HANDLER(set_active_window)
2141 {
2142     struct msg_queue *queue = get_current_queue();
2143
2144     reply->previous = 0;
2145     if (queue && check_queue_input_window( queue, req->handle ))
2146     {
2147         if (!req->handle || make_window_active( req->handle ))
2148         {
2149             reply->previous = queue->input->active;
2150             queue->input->active = get_user_full_handle( req->handle );
2151         }
2152         else set_error( STATUS_INVALID_HANDLE );
2153     }
2154 }
2155
2156
2157 /* set the current thread capture window */
2158 DECL_HANDLER(set_capture_window)
2159 {
2160     struct msg_queue *queue = get_current_queue();
2161
2162     reply->previous = reply->full_handle = 0;
2163     if (queue && check_queue_input_window( queue, req->handle ))
2164     {
2165         struct thread_input *input = queue->input;
2166
2167         reply->previous = input->capture;
2168         input->capture = get_user_full_handle( req->handle );
2169         input->menu_owner = (req->flags & CAPTURE_MENU) ? input->capture : 0;
2170         input->move_size = (req->flags & CAPTURE_MOVESIZE) ? input->capture : 0;
2171         reply->full_handle = input->capture;
2172     }
2173 }
2174
2175
2176 /* Set the current thread caret window */
2177 DECL_HANDLER(set_caret_window)
2178 {
2179     struct msg_queue *queue = get_current_queue();
2180
2181     reply->previous = 0;
2182     if (queue && check_queue_input_window( queue, req->handle ))
2183     {
2184         struct thread_input *input = queue->input;
2185
2186         reply->previous  = input->caret;
2187         reply->old_rect  = input->caret_rect;
2188         reply->old_hide  = input->caret_hide;
2189         reply->old_state = input->caret_state;
2190
2191         set_caret_window( input, get_user_full_handle(req->handle) );
2192         input->caret_rect.right  = input->caret_rect.left + req->width;
2193         input->caret_rect.bottom = input->caret_rect.top + req->height;
2194     }
2195 }
2196
2197
2198 /* Set the current thread caret information */
2199 DECL_HANDLER(set_caret_info)
2200 {
2201     struct msg_queue *queue = get_current_queue();
2202     struct thread_input *input;
2203
2204     if (!queue) return;
2205     input = queue->input;
2206     reply->full_handle = input->caret;
2207     reply->old_rect    = input->caret_rect;
2208     reply->old_hide    = input->caret_hide;
2209     reply->old_state   = input->caret_state;
2210
2211     if (req->handle && get_user_full_handle(req->handle) != input->caret)
2212     {
2213         set_error( STATUS_ACCESS_DENIED );
2214         return;
2215     }
2216     if (req->flags & SET_CARET_POS)
2217     {
2218         input->caret_rect.right  += req->x - input->caret_rect.left;
2219         input->caret_rect.bottom += req->y - input->caret_rect.top;
2220         input->caret_rect.left = req->x;
2221         input->caret_rect.top  = req->y;
2222     }
2223     if (req->flags & SET_CARET_HIDE)
2224     {
2225         input->caret_hide += req->hide;
2226         if (input->caret_hide < 0) input->caret_hide = 0;
2227     }
2228     if (req->flags & SET_CARET_STATE)
2229     {
2230         if (req->state == -1) input->caret_state = !input->caret_state;
2231         else input->caret_state = !!req->state;
2232     }
2233 }
2234
2235
2236 /* get the time of the last input event */
2237 DECL_HANDLER(get_last_input_time)
2238 {
2239     reply->time = last_input_time;
2240 }