?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 337eb2e2d902d84a5d689451984c5832d7e04fc4
[wine/hacks.git] / dlls / winex11.drv / event.c
blob5f7ebef24364169e6cbb44a0e108d5dc3640917a
1 /*
2 * X11 event driver
3 *
4 * Copyright 1993 Alexandre Julliard
5 * 1999 Noel Borthwick
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23
24 #ifdef HAVE_POLL_H
25 #include <poll.h>
26 #endif
27 #ifdef HAVE_SYS_POLL_H
28 #include <sys/poll.h>
29 #endif
30 #include <X11/Xatom.h>
31 #include <X11/keysym.h>
32 #include <X11/Xlib.h>
33 #include <X11/Xresource.h>
34 #include <X11/Xutil.h>
35
36 #include <assert.h>
37 #include <stdarg.h>
38 #include <string.h>
39
40 #define NONAMELESSUNION
41 #define NONAMELESSSTRUCT
42 #include "windef.h"
43 #include "winbase.h"
44 #include "winuser.h"
45 #include "wingdi.h"
46
47 #include "x11drv.h"
48
49 /* avoid conflict with field names in included win32 headers */
50 #undef Status
51 #include "shlobj.h" /* DROPFILES */
52 #include "shellapi.h"
53
54 #include "wine/server.h"
55 #include "wine/debug.h"
56
57 WINE_DEFAULT_DEBUG_CHANNEL(event);
58
59 extern BOOL ximInComposeMode;
60
61 #define DndNotDnd -1 /* OffiX drag&drop */
62 #define DndUnknown 0
63 #define DndRawData 1
64 #define DndFile 2
65 #define DndFiles 3
66 #define DndText 4
67 #define DndDir 5
68 #define DndLink 6
69 #define DndExe 7
70
71 #define DndEND 8
72
73 #define DndURL 128 /* KDE drag&drop */
74
75 /* Event handlers */
76 static void X11DRV_FocusIn( HWND hwnd, XEvent *event );
77 static void X11DRV_FocusOut( HWND hwnd, XEvent *event );
78 static void X11DRV_Expose( HWND hwnd, XEvent *event );
79 static void X11DRV_MapNotify( HWND hwnd, XEvent *event );
80 static void X11DRV_ConfigureNotify( HWND hwnd, XEvent *event );
81 static void X11DRV_PropertyNotify( HWND hwnd, XEvent *event );
82 static void X11DRV_ClientMessage( HWND hwnd, XEvent *event );
83
84 struct event_handler
85 {
86 int type; /* event type */
87 x11drv_event_handler handler; /* corresponding handler function */
88 };
89
90 #define MAX_EVENT_HANDLERS 64
91
92 static struct event_handler handlers[MAX_EVENT_HANDLERS] =
93 {
94 /* list must be sorted by event type */
95 { KeyPress, X11DRV_KeyEvent },
96 { KeyRelease, X11DRV_KeyEvent },
97 { ButtonPress, X11DRV_ButtonPress },
98 { ButtonRelease, X11DRV_ButtonRelease },
99 { MotionNotify, X11DRV_MotionNotify },
100 { EnterNotify, X11DRV_EnterNotify },
101 /* LeaveNotify */
102 { FocusIn, X11DRV_FocusIn },
103 { FocusOut, X11DRV_FocusOut },
104 { KeymapNotify, X11DRV_KeymapNotify },
105 { Expose, X11DRV_Expose },
106 /* GraphicsExpose */
107 /* NoExpose */
108 /* VisibilityNotify */
109 /* CreateNotify */
110 { DestroyNotify, X11DRV_DestroyNotify },
111 /* UnmapNotify */
112 { MapNotify, X11DRV_MapNotify },
113 /* MapRequest */
114 /* ReparentNotify */
115 { ConfigureNotify, X11DRV_ConfigureNotify },
116 /* ConfigureRequest */
117 /* GravityNotify */
118 /* ResizeRequest */
119 /* CirculateNotify */
120 /* CirculateRequest */
121 { PropertyNotify, X11DRV_PropertyNotify },
122 { SelectionClear, X11DRV_SelectionClear },
123 { SelectionRequest, X11DRV_SelectionRequest },
124 /* SelectionNotify */
125 /* ColormapNotify */
126 { ClientMessage, X11DRV_ClientMessage },
127 { MappingNotify, X11DRV_MappingNotify },
128 };
129
130 static int nb_event_handlers = 18; /* change this if you add handlers above */
131
132
133 /* return the name of an X event */
134 static const char *dbgstr_event( int type )
135 {
136 static const char * const event_names[] =
137 {
138 "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease",
139 "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut",
140 "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify",
141 "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",
142 "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify",
143 "ResizeRequest", "CirculateNotify", "CirculateRequest", "PropertyNotify",
144 "SelectionClear", "SelectionRequest", "SelectionNotify", "ColormapNotify",
145 "ClientMessage", "MappingNotify"
146 };
147
148 if (type >= KeyPress && type <= MappingNotify) return event_names[type - KeyPress];
149 return wine_dbg_sprintf( "Extension event %d", type );
150 }
151
152
153 /***********************************************************************
154 * find_handler
155 *
156 * Find the handler for a given event type. Caller must hold the x11 lock.
157 */
158 static inline x11drv_event_handler find_handler( int type )
159 {
160 int min = 0, max = nb_event_handlers - 1;
161
162 while (min <= max)
163 {
164 int pos = (min + max) / 2;
165 if (handlers[pos].type == type) return handlers[pos].handler;
166 if (handlers[pos].type > type) max = pos - 1;
167 else min = pos + 1;
168 }
169 return NULL;
170 }
171
172
173 /***********************************************************************
174 * X11DRV_register_event_handler
175 *
176 * Register a handler for a given event type.
177 * If already registered, overwrite the previous handler.
178 */
179 void X11DRV_register_event_handler( int type, x11drv_event_handler handler )
180 {
181 int min, max;
182
183 wine_tsx11_lock();
184 min = 0;
185 max = nb_event_handlers - 1;
186 while (min <= max)
187 {
188 int pos = (min + max) / 2;
189 if (handlers[pos].type == type)
190 {
191 handlers[pos].handler = handler;
192 goto done;
193 }
194 if (handlers[pos].type > type) max = pos - 1;
195 else min = pos + 1;
196 }
197 /* insert it between max and min */
198 memmove( &handlers[min+1], &handlers[min], (nb_event_handlers - min) * sizeof(handlers[0]) );
199 handlers[min].type = type;
200 handlers[min].handler = handler;
201 nb_event_handlers++;
202 assert( nb_event_handlers <= MAX_EVENT_HANDLERS );
203 done:
204 wine_tsx11_unlock();
205 TRACE("registered handler %p for event %d count %d\n", handler, type, nb_event_handlers );
206 }
207
208
209 /***********************************************************************
210 * filter_event
211 */
212 static Bool filter_event( Display *display, XEvent *event, char *arg )
213 {
214 ULONG_PTR mask = (ULONG_PTR)arg;
215
216 if ((mask & QS_ALLINPUT) == QS_ALLINPUT) return 1;
217
218 switch(event->type)
219 {
220 case KeyPress:
221 case KeyRelease:
222 case KeymapNotify:
223 case MappingNotify:
224 return (mask & QS_KEY) != 0;
225 case ButtonPress:
226 case ButtonRelease:
227 return (mask & QS_MOUSEBUTTON) != 0;
228 case MotionNotify:
229 case EnterNotify:
230 case LeaveNotify:
231 return (mask & QS_MOUSEMOVE) != 0;
232 case Expose:
233 return (mask & QS_PAINT) != 0;
234 case FocusIn:
235 case FocusOut:
236 case MapNotify:
237 case UnmapNotify:
238 case ConfigureNotify:
239 case PropertyNotify:
240 case ClientMessage:
241 return (mask & QS_POSTMESSAGE) != 0;
242 default:
243 return (mask & QS_SENDMESSAGE) != 0;
244 }
245 }
246
247
248 enum event_merge_action
249 {
250 MERGE_DISCARD, /* discard the old event */
251 MERGE_HANDLE, /* handle the old event */
252 MERGE_KEEP /* keep the old event for future merging */
253 };
254
255 /***********************************************************************
256 * merge_events
257 *
258 * Try to merge 2 consecutive events.
259 */
260 static enum event_merge_action merge_events( XEvent *prev, XEvent *next )
261 {
262 switch (prev->type)
263 {
264 case ConfigureNotify:
265 switch (next->type)
266 {
267 case ConfigureNotify:
268 if (prev->xany.window == next->xany.window)
269 {
270 TRACE( "discarding duplicate ConfigureNotify for window %lx\n", prev->xany.window );
271 return MERGE_DISCARD;
272 }
273 break;
274 case Expose:
275 case PropertyNotify:
276 return MERGE_KEEP;
277 }
278 break;
279 case MotionNotify:
280 if (prev->xany.window == next->xany.window && next->type == MotionNotify)
281 {
282 TRACE( "discarding duplicate MotionNotify for window %lx\n", prev->xany.window );
283 return MERGE_DISCARD;
284 }
285 break;
286 }
287 return MERGE_HANDLE;
288 }
289
290
291 /***********************************************************************
292 * call_event_handler
293 */
294 static inline void call_event_handler( Display *display, XEvent *event )
295 {
296 HWND hwnd;
297 x11drv_event_handler handler;
298 XEvent *prev;
299 struct x11drv_thread_data *thread_data;
300
301 if (!(handler = find_handler( event->type )))
302 {
303 TRACE( "%s for win %lx, ignoring\n", dbgstr_event( event->type ), event->xany.window );
304 return; /* no handler, ignore it */
305 }
306
307 if (XFindContext( display, event->xany.window, winContext, (char **)&hwnd ) != 0)
308 hwnd = 0; /* not for a registered window */
309 if (!hwnd && event->xany.window == root_window) hwnd = GetDesktopWindow();
310
311 TRACE( "%s for hwnd/window %p/%lx\n",
312 dbgstr_event( event->type ), hwnd, event->xany.window );
313 wine_tsx11_unlock();
314 thread_data = x11drv_thread_data();
315 prev = thread_data->current_event;
316 thread_data->current_event = event;
317 handler( hwnd, event );
318 thread_data->current_event = prev;
319 wine_tsx11_lock();
320 }
321
322
323 /***********************************************************************
324 * process_events
325 */
326 static int process_events( Display *display, Bool (*filter)(), ULONG_PTR arg )
327 {
328 XEvent event, prev_event;
329 int count = 0;
330 enum event_merge_action action = MERGE_DISCARD;
331
332 prev_event.type = 0;
333 wine_tsx11_lock();
334 while (XCheckIfEvent( display, &event, filter, (char *)arg ))
335 {
336 count++;
337 if (XFilterEvent( &event, None ))
338 {
339 /*
340 * SCIM on linux filters key events strangely. It does not filter the
341 * KeyPress events for these keys however it does filter the
342 * KeyRelease events. This causes wine to become very confused as
343 * to the keyboard state.
344 *
345 * We need to let those KeyRelease events be processed so that the
346 * keyboard state is correct.
347 */
348 if (event.type == KeyRelease)
349 {
350 KeySym keysym = 0;
351 XKeyEvent *keyevent = &event.xkey;
352
353 XLookupString(keyevent, NULL, 0, &keysym, NULL);
354 if (!(keysym == XK_Shift_L ||
355 keysym == XK_Shift_R ||
356 keysym == XK_Control_L ||
357 keysym == XK_Control_R ||
358 keysym == XK_Alt_R ||
359 keysym == XK_Alt_L ||
360 keysym == XK_Meta_R ||
361 keysym == XK_Meta_L))
362 continue; /* not a key we care about, ignore it */
363 }
364 else
365 continue; /* filtered, ignore it */
366 }
367 if (prev_event.type) action = merge_events( &prev_event, &event );
368 switch( action )
369 {
370 case MERGE_DISCARD: /* discard prev, keep new */
371 prev_event = event;
372 break;
373 case MERGE_HANDLE: /* handle prev, keep new */
374 call_event_handler( display, &prev_event );
375 prev_event = event;
376 break;
377 case MERGE_KEEP: /* handle new, keep prev for future merging */
378 call_event_handler( display, &event );
379 break;
380 }
381 }
382 XFlush( gdi_display );
383 if (prev_event.type) call_event_handler( display, &prev_event );
384 wine_tsx11_unlock();
385 if (count) TRACE( "processed %d events\n", count );
386 return count;
387 }
388
389
390 /***********************************************************************
391 * MsgWaitForMultipleObjectsEx (X11DRV.@)
392 */
393 DWORD X11DRV_MsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
394 DWORD timeout, DWORD mask, DWORD flags )
395 {
396 DWORD ret;
397 struct x11drv_thread_data *data = TlsGetValue( thread_data_tls_index );
398
399 if (!data)
400 {
401 if (!count && !timeout) return WAIT_TIMEOUT;
402 return WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
403 timeout, flags & MWMO_ALERTABLE );
404 }
405
406 if (data->current_event) mask = 0; /* don't process nested events */
407
408 if (process_events( data->display, filter_event, mask )) ret = count - 1;
409 else if (count || timeout)
410 {
411 ret = WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
412 timeout, flags & MWMO_ALERTABLE );
413 if (ret == count - 1) process_events( data->display, filter_event, mask );
414 }
415 else ret = WAIT_TIMEOUT;
416
417 return ret;
418 }
419
420 /***********************************************************************
421 * EVENT_x11_time_to_win32_time
422 *
423 * Make our timer and the X timer line up as best we can
424 * Pass 0 to retrieve the current adjustment value (times -1)
425 */
426 DWORD EVENT_x11_time_to_win32_time(Time time)
427 {
428 static DWORD adjust = 0;
429 DWORD now = GetTickCount();
430 DWORD ret;
431
432 if (! adjust && time != 0)
433 {
434 ret = now;
435 adjust = time - now;
436 }
437 else
438 {
439 /* If we got an event in the 'future', then our clock is clearly wrong.
440 If we got it more than 10000 ms in the future, then it's most likely
441 that the clock has wrapped. */
442
443 ret = time - adjust;
444 if (ret > now && ((ret - now) < 10000) && time != 0)
445 {
446 adjust += ret - now;
447 ret -= ret - now;
448 }
449 }
450
451 return ret;
452
453 }
454
455 /*******************************************************************
456 * can_activate_window
457 *
458 * Check if we can activate the specified window.
459 */
460 static inline BOOL can_activate_window( HWND hwnd )
461 {
462 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
463 if (!(style & WS_VISIBLE)) return FALSE;
464 if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return FALSE;
465 if (hwnd == GetDesktopWindow()) return FALSE;
466 return !(style & WS_DISABLED);
467 }
468
469
470 /**********************************************************************
471 * set_focus
472 */
473 static void set_focus( Display *display, HWND hwnd, Time time )
474 {
475 HWND focus;
476 Window win;
477
478 TRACE( "setting foreground window to %p\n", hwnd );
479 SetForegroundWindow( hwnd );
480
481 focus = GetFocus();
482 if (focus) focus = GetAncestor( focus, GA_ROOT );
483 win = X11DRV_get_whole_window(focus);
484
485 if (win)
486 {
487 TRACE( "setting focus to %p (%lx) time=%ld\n", focus, win, time );
488 wine_tsx11_lock();
489 XSetInputFocus( display, win, RevertToParent, time );
490 wine_tsx11_unlock();
491 }
492 }
493
494
495 /**********************************************************************
496 * handle_wm_protocols
497 */
498 static void handle_wm_protocols( HWND hwnd, XClientMessageEvent *event )
499 {
500 Atom protocol = (Atom)event->data.l[0];
501
502 if (!protocol) return;
503
504 if (protocol == x11drv_atom(WM_DELETE_WINDOW))
505 {
506 /* Ignore the delete window request if the window has been disabled
507 * and we are in managed mode. This is to disallow applications from
508 * being closed by the window manager while in a modal state.
509 */
510 if (IsWindowEnabled(hwnd))
511 {
512 HMENU hSysMenu;
513
514 if (GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE) return;
515 hSysMenu = GetSystemMenu(hwnd, FALSE);
516 if (hSysMenu)
517 {
518 UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
519 if (state == 0xFFFFFFFF || (state & (MF_DISABLED | MF_GRAYED)))
520 return;
521 }
522 if (GetActiveWindow() != hwnd)
523 {
524 LRESULT ma = SendMessageW( hwnd, WM_MOUSEACTIVATE,
525 (WPARAM)GetAncestor( hwnd, GA_ROOT ),
526 MAKELONG(HTCLOSE,WM_LBUTTONDOWN) );
527 switch(ma)
528 {
529 case MA_NOACTIVATEANDEAT:
530 case MA_ACTIVATEANDEAT:
531 return;
532 case MA_NOACTIVATE:
533 break;
534 case MA_ACTIVATE:
535 case 0:
536 SetActiveWindow(hwnd);
537 break;
538 default:
539 WARN( "unknown WM_MOUSEACTIVATE code %d\n", (int) ma );
540 break;
541 }
542 }
543 PostMessageW( hwnd, WM_X11DRV_DELETE_WINDOW, 0, 0 );
544 }
545 }
546 else if (protocol == x11drv_atom(WM_TAKE_FOCUS))
547 {
548 Time event_time = (Time)event->data.l[1];
549 HWND last_focus = x11drv_thread_data()->last_focus;
550
551 TRACE( "got take focus msg for %p, enabled=%d, visible=%d (style %08x), focus=%p, active=%p, fg=%p, last=%p\n",
552 hwnd, IsWindowEnabled(hwnd), IsWindowVisible(hwnd), GetWindowLongW(hwnd, GWL_STYLE),
553 GetFocus(), GetActiveWindow(), GetForegroundWindow(), last_focus );
554
555 if (can_activate_window(hwnd))
556 {
557 /* simulate a mouse click on the caption to find out
558 * whether the window wants to be activated */
559 LRESULT ma = SendMessageW( hwnd, WM_MOUSEACTIVATE,
560 (WPARAM)GetAncestor( hwnd, GA_ROOT ),
561 MAKELONG(HTCAPTION,WM_LBUTTONDOWN) );
562 if (ma != MA_NOACTIVATEANDEAT && ma != MA_NOACTIVATE)
563 {
564 set_focus( event->display, hwnd, event_time );
565 return;
566 }
567 }
568 /* try to find some other window to give the focus to */
569 hwnd = GetFocus();
570 if (hwnd) hwnd = GetAncestor( hwnd, GA_ROOT );
571 if (!hwnd) hwnd = GetActiveWindow();
572 if (!hwnd) hwnd = last_focus;
573 if (hwnd && can_activate_window(hwnd)) set_focus( event->display, hwnd, event_time );
574 }
575 else if (protocol == x11drv_atom(_NET_WM_PING))
576 {
577 XClientMessageEvent xev;
578 xev = *event;
579
580 TRACE("NET_WM Ping\n");
581 wine_tsx11_lock();
582 xev.window = DefaultRootWindow(xev.display);
583 XSendEvent(xev.display, xev.window, False, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent*)&xev);
584 wine_tsx11_unlock();
585 /* this line is semi-stolen from gtk2 */
586 TRACE("NET_WM Pong\n");
587 }
588 }
589
590
591 static const char * const focus_details[] =
592 {
593 "NotifyAncestor",
594 "NotifyVirtual",
595 "NotifyInferior",
596 "NotifyNonlinear",
597 "NotifyNonlinearVirtual",
598 "NotifyPointer",
599 "NotifyPointerRoot",
600 "NotifyDetailNone"
601 };
602
603 /**********************************************************************
604 * X11DRV_FocusIn
605 */
606 static void X11DRV_FocusIn( HWND hwnd, XEvent *xev )
607 {
608 XFocusChangeEvent *event = &xev->xfocus;
609 XIC xic;
610
611 if (!hwnd) return;
612
613 TRACE( "win %p xwin %lx detail=%s\n", hwnd, event->window, focus_details[event->detail] );
614
615 if (event->detail == NotifyPointer) return;
616
617 if ((xic = X11DRV_get_ic( hwnd )))
618 {
619 wine_tsx11_lock();
620 XSetICFocus( xic );
621 wine_tsx11_unlock();
622 }
623 if (use_take_focus) return; /* ignore FocusIn if we are using take focus */
624
625 if (!can_activate_window(hwnd))
626 {
627 HWND hwnd = GetFocus();
628 if (hwnd) hwnd = GetAncestor( hwnd, GA_ROOT );
629 if (!hwnd) hwnd = GetActiveWindow();
630 if (!hwnd) hwnd = x11drv_thread_data()->last_focus;
631 if (hwnd && can_activate_window(hwnd)) set_focus( event->display, hwnd, CurrentTime );
632 }
633 else SetForegroundWindow( hwnd );
634 }
635
636
637 /**********************************************************************
638 * X11DRV_FocusOut
639 *
640 * Note: only top-level windows get FocusOut events.
641 */
642 static void X11DRV_FocusOut( HWND hwnd, XEvent *xev )
643 {
644 XFocusChangeEvent *event = &xev->xfocus;
645 HWND hwnd_tmp;
646 Window focus_win;
647 int revert;
648 XIC xic;
649
650 if (!hwnd) return;
651
652 TRACE( "win %p xwin %lx detail=%s\n", hwnd, event->window, focus_details[event->detail] );
653
654 if (event->detail == NotifyPointer) return;
655 if (ximInComposeMode) return;
656
657 x11drv_thread_data()->last_focus = hwnd;
658 if ((xic = X11DRV_get_ic( hwnd )))
659 {
660 wine_tsx11_lock();
661 XUnsetICFocus( xic );
662 wine_tsx11_unlock();
663 }
664 if (hwnd != GetForegroundWindow()) return;
665 SendMessageW( hwnd, WM_CANCELMODE, 0, 0 );
666
667 /* don't reset the foreground window, if the window which is
668 getting the focus is a Wine window */
669
670 wine_tsx11_lock();
671 XGetInputFocus( event->display, &focus_win, &revert );
672 if (focus_win)
673 {
674 if (XFindContext( event->display, focus_win, winContext, (char **)&hwnd_tmp ) != 0)
675 focus_win = 0;
676 }
677 wine_tsx11_unlock();
678
679 if (!focus_win)
680 {
681 /* Abey : 6-Oct-99. Check again if the focus out window is the
682 Foreground window, because in most cases the messages sent
683 above must have already changed the foreground window, in which
684 case we don't have to change the foreground window to 0 */
685 if (hwnd == GetForegroundWindow())
686 {
687 TRACE( "lost focus, setting fg to desktop\n" );
688 SetForegroundWindow( GetDesktopWindow() );
689 }
690 }
691 }
692
693
694 /***********************************************************************
695 * X11DRV_Expose
696 */
697 static void X11DRV_Expose( HWND hwnd, XEvent *xev )
698 {
699 XExposeEvent *event = &xev->xexpose;
700 RECT rect;
701 struct x11drv_win_data *data;
702 int flags = RDW_INVALIDATE | RDW_ERASE;
703
704 TRACE( "win %p (%lx) %d,%d %dx%d\n",
705 hwnd, event->window, event->x, event->y, event->width, event->height );
706
707 if (!(data = X11DRV_get_win_data( hwnd ))) return;
708
709 if (event->window == data->whole_window)
710 {
711 rect.left = data->whole_rect.left + event->x;
712 rect.top = data->whole_rect.top + event->y;
713 flags |= RDW_FRAME;
714 }
715 else
716 {
717 rect.left = data->client_rect.left + event->x;
718 rect.top = data->client_rect.top + event->y;
719 }
720 rect.right = rect.left + event->width;
721 rect.bottom = rect.top + event->height;
722
723 if (event->window != root_window)
724 {
725 SERVER_START_REQ( update_window_zorder )
726 {
727 req->window = hwnd;
728 req->rect.left = rect.left;
729 req->rect.top = rect.top;
730 req->rect.right = rect.right;
731 req->rect.bottom = rect.bottom;
732 wine_server_call( req );
733 }
734 SERVER_END_REQ;
735
736 /* make position relative to client area instead of parent */
737 OffsetRect( &rect, -data->client_rect.left, -data->client_rect.top );
738 flags |= RDW_ALLCHILDREN;
739 }
740
741 RedrawWindow( hwnd, &rect, 0, flags );
742 }
743
744
745 /**********************************************************************
746 * X11DRV_MapNotify
747 */
748 static void X11DRV_MapNotify( HWND hwnd, XEvent *event )
749 {
750 struct x11drv_win_data *data;
751
752 if (!(data = X11DRV_get_win_data( hwnd ))) return;
753 if (!data->mapped) return;
754
755 if (!data->managed)
756 {
757 HWND hwndFocus = GetFocus();
758 if (hwndFocus && IsChild( hwnd, hwndFocus )) X11DRV_SetFocus(hwndFocus); /* FIXME */
759 }
760 }
761
762
763 /***********************************************************************
764 * is_net_wm_state_maximized
765 */
766 static BOOL is_net_wm_state_maximized( Display *display, struct x11drv_win_data *data )
767 {
768 Atom type, *state;
769 int format, ret = 0;
770 unsigned long i, count, remaining;
771
772 wine_tsx11_lock();
773 if (!XGetWindowProperty( display, data->whole_window, x11drv_atom(_NET_WM_STATE), 0,
774 65536/sizeof(CARD32), False, XA_ATOM, &type, &format, &count,
775 &remaining, (unsigned char **)&state ))
776 {
777 if (type == XA_ATOM && format == 32)
778 {
779 for (i = 0; i < count; i++)
780 {
781 if (state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_VERT) ||
782 state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ))
783 ret++;
784 }
785 }
786 XFree( state );
787 }
788 wine_tsx11_unlock();
789 return (ret == 2);
790 }
791
792
793 /***********************************************************************
794 * X11DRV_ConfigureNotify
795 */
796 void X11DRV_ConfigureNotify( HWND hwnd, XEvent *xev )
797 {
798 XConfigureEvent *event = &xev->xconfigure;
799 struct x11drv_win_data *data;
800 RECT rect;
801 UINT flags;
802 int cx, cy, x = event->x, y = event->y;
803
804 if (!hwnd) return;
805 if (!(data = X11DRV_get_win_data( hwnd ))) return;
806 if (!data->mapped || data->iconic) return;
807
808 /* Get geometry */
809
810 if (!event->send_event) /* normal event, need to map coordinates to the root */
811 {
812 Window child;
813 wine_tsx11_lock();
814 XTranslateCoordinates( event->display, data->whole_window, root_window,
815 0, 0, &x, &y, &child );
816 wine_tsx11_unlock();
817 }
818 rect.left = x;
819 rect.top = y;
820 rect.right = x + event->width;
821 rect.bottom = y + event->height;
822 OffsetRect( &rect, virtual_screen_rect.left, virtual_screen_rect.top );
823 TRACE( "win %p/%lx new X rect %d,%d,%dx%d (event %d,%d,%dx%d)\n",
824 hwnd, data->whole_window, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
825 event->x, event->y, event->width, event->height );
826 X11DRV_X_to_window_rect( data, &rect );
827
828 if (is_net_wm_state_maximized( event->display, data ))
829 {
830 if (!IsZoomed( data->hwnd ))
831 {
832 TRACE( "win %p/%lx is maximized\n", data->hwnd, data->whole_window );
833 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
834 return;
835 }
836 }
837 else
838 {
839 if (IsZoomed( data->hwnd ))
840 {
841 TRACE( "window %p/%lx is no longer maximized\n", data->hwnd, data->whole_window );
842 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0 );
843 return;
844 }
845 }
846
847 /* Compare what has changed */
848
849 x = rect.left;
850 y = rect.top;
851 cx = rect.right - rect.left;
852 cy = rect.bottom - rect.top;
853 flags = SWP_NOACTIVATE | SWP_NOZORDER;
854
855 if (data->window_rect.left == x && data->window_rect.top == y) flags |= SWP_NOMOVE;
856 else
857 TRACE( "%p moving from (%d,%d) to (%d,%d)\n",
858 hwnd, data->window_rect.left, data->window_rect.top, x, y );
859
860 if ((data->window_rect.right - data->window_rect.left == cx &&
861 data->window_rect.bottom - data->window_rect.top == cy) ||
862 (IsRectEmpty( &data->window_rect ) && event->width == 1 && event->height == 1))
863 {
864 if (flags & SWP_NOMOVE) return; /* if nothing changed, don't do anything */
865 flags |= SWP_NOSIZE;
866 }
867 else
868 TRACE( "%p resizing from (%dx%d) to (%dx%d)\n",
869 hwnd, data->window_rect.right - data->window_rect.left,
870 data->window_rect.bottom - data->window_rect.top, cx, cy );
871
872 SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
873 }
874
875
876 /***********************************************************************
877 * get_window_wm_state
878 */
879 static int get_window_wm_state( Display *display, struct x11drv_win_data *data )
880 {
881 struct
882 {
883 CARD32 state;
884 XID icon;
885 } *state;
886 Atom type;
887 int format, ret = -1;
888 unsigned long count, remaining;
889
890 wine_tsx11_lock();
891 if (!XGetWindowProperty( display, data->whole_window, x11drv_atom(WM_STATE), 0,
892 sizeof(*state)/sizeof(CARD32), False, x11drv_atom(WM_STATE),
893 &type, &format, &count, &remaining, (unsigned char **)&state ))
894 {
895 if (type == x11drv_atom(WM_STATE) && get_property_size( format, count ) >= sizeof(*state))
896 ret = state->state;
897 XFree( state );
898 }
899 wine_tsx11_unlock();
900 return ret;
901 }
902
903
904 /***********************************************************************
905 * handle_wm_state_notify
906 *
907 * Handle a PropertyNotify for WM_STATE.
908 */
909 static void handle_wm_state_notify( struct x11drv_win_data *data, XPropertyEvent *event,
910 BOOL update_window )
911 {
912 switch(event->state)
913 {
914 case PropertyDelete:
915 TRACE( "%p/%lx: WM_STATE deleted from %d\n", data->hwnd, data->whole_window, data->wm_state );
916 data->wm_state = WithdrawnState;
917 break;
918 case PropertyNewValue:
919 {
920 int old_state = data->wm_state;
921 int new_state = get_window_wm_state( event->display, data );
922 if (new_state != -1 && new_state != data->wm_state)
923 {
924 TRACE( "%p/%lx: new WM_STATE %d from %d\n",
925 data->hwnd, data->whole_window, new_state, old_state );
926 data->wm_state = new_state;
927 /* ignore the initial state transition out of withdrawn state */
928 /* metacity does Withdrawn->NormalState->IconicState when mapping an iconic window */
929 if (!old_state) return;
930 }
931 }
932 break;
933 }
934
935 if (!update_window || !data->managed || !data->mapped) return;
936
937 if (data->iconic && data->wm_state == NormalState) /* restore window */
938 {
939 data->iconic = FALSE;
940 if (is_net_wm_state_maximized( event->display, data ))
941 {
942 TRACE( "restoring to max %p/%lx\n", data->hwnd, data->whole_window );
943 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
944 }
945 else
946 {
947 TRACE( "restoring win %p/%lx\n", data->hwnd, data->whole_window );
948 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0 );
949 }
950 }
951 else if (!data->iconic && data->wm_state == IconicState)
952 {
953 TRACE( "minimizing win %p/%lx\n", data->hwnd, data->whole_window );
954 data->iconic = TRUE;
955 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0 );
956 }
957 }
958
959
960 /***********************************************************************
961 * X11DRV_PropertyNotify
962 */
963 static void X11DRV_PropertyNotify( HWND hwnd, XEvent *xev )
964 {
965 XPropertyEvent *event = &xev->xproperty;
966 struct x11drv_win_data *data;
967
968 if (!hwnd) return;
969 if (!(data = X11DRV_get_win_data( hwnd ))) return;
970
971 if (event->atom == x11drv_atom(WM_STATE)) handle_wm_state_notify( data, event, TRUE );
972 }
973
974
975 /* event filter to wait for a WM_STATE change notification on a window */
976 static Bool is_wm_state_notify( Display *display, XEvent *event, XPointer arg )
977 {
978 if (event->xany.window != (Window)arg) return 0;
979 return (event->type == DestroyNotify ||
980 (event->type == PropertyNotify && event->xproperty.atom == x11drv_atom(WM_STATE)));
981 }
982
983 /***********************************************************************
984 * wait_for_withdrawn_state
985 */
986 void wait_for_withdrawn_state( Display *display, struct x11drv_win_data *data, BOOL set )
987 {
988 DWORD end = GetTickCount() + 2000;
989
990 if (!data->managed) return;
991
992 TRACE( "waiting for window %p/%lx to become %swithdrawn\n",
993 data->hwnd, data->whole_window, set ? "" : "not " );
994
995 while (data->whole_window && ((data->wm_state == WithdrawnState) == !set))
996 {
997 XEvent event;
998 int count = 0;
999
1000 wine_tsx11_lock();
1001 while (XCheckIfEvent( display, &event, is_wm_state_notify, (char *)data->whole_window ))
1002 {
1003 count++;
1004 if (XFilterEvent( &event, None )) continue; /* filtered, ignore it */
1005 if (event.type == DestroyNotify) call_event_handler( display, &event );
1006 else
1007 {
1008 wine_tsx11_unlock();
1009 handle_wm_state_notify( data, &event.xproperty, FALSE );
1010 wine_tsx11_lock();
1011 }
1012 }
1013 wine_tsx11_unlock();
1014
1015 if (!count)
1016 {
1017 struct pollfd pfd;
1018 int timeout = end - GetTickCount();
1019
1020 pfd.fd = ConnectionNumber(display);
1021 pfd.events = POLLIN;
1022 if (timeout <= 0 || poll( &pfd, 1, timeout ) != 1)
1023 {
1024 FIXME( "window %p/%lx wait timed out\n", data->hwnd, data->whole_window );
1025 break;
1026 }
1027 }
1028 }
1029 TRACE( "window %p/%lx state now %d\n", data->hwnd, data->whole_window, data->wm_state );
1030 }
1031
1032
1033 static HWND find_drop_window( HWND hQueryWnd, LPPOINT lpPt )
1034 {
1035 RECT tempRect;
1036
1037 if (!IsWindowEnabled(hQueryWnd)) return 0;
1038
1039 GetWindowRect(hQueryWnd, &tempRect);
1040
1041 if(!PtInRect(&tempRect, *lpPt)) return 0;
1042
1043 if (!IsIconic( hQueryWnd ))
1044 {
1045 POINT pt = *lpPt;
1046 ScreenToClient( hQueryWnd, &pt );
1047 GetClientRect( hQueryWnd, &tempRect );
1048
1049 if (PtInRect( &tempRect, pt))
1050 {
1051 HWND ret = ChildWindowFromPointEx( hQueryWnd, pt, CWP_SKIPINVISIBLE|CWP_SKIPDISABLED );
1052 if (ret && ret != hQueryWnd)
1053 {
1054 ret = find_drop_window( ret, lpPt );
1055 if (ret) return ret;
1056 }
1057 }
1058 }
1059
1060 if(!(GetWindowLongA( hQueryWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return 0;
1061
1062 ScreenToClient(hQueryWnd, lpPt);
1063
1064 return hQueryWnd;
1065 }
1066
1067 /**********************************************************************
1068 * EVENT_DropFromOffix
1069 *
1070 * don't know if it still works (last Changelog is from 96/11/04)
1071 */
1072 static void EVENT_DropFromOffiX( HWND hWnd, XClientMessageEvent *event )
1073 {
1074 struct x11drv_win_data *data;
1075 unsigned long data_length;
1076 unsigned long aux_long;
1077 unsigned char* p_data = NULL;
1078 Atom atom_aux;
1079 int x, y, dummy;
1080 BOOL bAccept;
1081 Window win, w_aux_root, w_aux_child;
1082
1083 win = X11DRV_get_whole_window(hWnd);
1084 wine_tsx11_lock();
1085 XQueryPointer( event->display, win, &w_aux_root, &w_aux_child,
1086 &x, &y, &dummy, &dummy, (unsigned int*)&aux_long);
1087 x += virtual_screen_rect.left;
1088 y += virtual_screen_rect.top;
1089 wine_tsx11_unlock();
1090
1091 if (!(data = X11DRV_get_win_data( hWnd ))) return;
1092
1093 /* find out drop point and drop window */
1094 if( x < 0 || y < 0 ||
1095 x > (data->whole_rect.right - data->whole_rect.left) ||
1096 y > (data->whole_rect.bottom - data->whole_rect.top) )
1097 {
1098 bAccept = GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES;
1099 x = 0;
1100 y = 0;
1101 }
1102 else
1103 {
1104 POINT pt = { x, y };
1105 HWND hwndDrop = find_drop_window( hWnd, &pt );
1106 if (hwndDrop)
1107 {
1108 x = pt.x;
1109 y = pt.y;
1110 bAccept = TRUE;
1111 }
1112 else
1113 {
1114 bAccept = FALSE;
1115 }
1116 }
1117
1118 if (!bAccept) return;
1119
1120 wine_tsx11_lock();
1121 XGetWindowProperty( event->display, DefaultRootWindow(event->display),
1122 x11drv_atom(DndSelection), 0, 65535, FALSE,
1123 AnyPropertyType, &atom_aux, &dummy,
1124 &data_length, &aux_long, &p_data);
1125 wine_tsx11_unlock();
1126
1127 if( !aux_long && p_data) /* don't bother if > 64K */
1128 {
1129 char *p = (char *)p_data;
1130 char *p_drop;
1131
1132 aux_long = 0;
1133 while( *p ) /* calculate buffer size */
1134 {
1135 INT len = GetShortPathNameA( p, NULL, 0 );
1136 if (len) aux_long += len + 1;
1137 p += strlen(p) + 1;
1138 }
1139 if( aux_long && aux_long < 65535 )
1140 {
1141 HDROP hDrop;
1142 DROPFILES *lpDrop;
1143
1144 aux_long += sizeof(DROPFILES) + 1;
1145 hDrop = GlobalAlloc( GMEM_SHARE, aux_long );
1146 lpDrop = GlobalLock( hDrop );
1147
1148 if( lpDrop )
1149 {
1150 lpDrop->pFiles = sizeof(DROPFILES);
1151 lpDrop->pt.x = x;
1152 lpDrop->pt.y = y;
1153 lpDrop->fNC = FALSE;
1154 lpDrop->fWide = FALSE;
1155 p_drop = (char *)(lpDrop + 1);
1156 p = (char *)p_data;
1157 while(*p)
1158 {
1159 if (GetShortPathNameA( p, p_drop, aux_long - (p_drop - (char *)lpDrop) ))
1160 p_drop += strlen( p_drop ) + 1;
1161 p += strlen(p) + 1;
1162 }
1163 *p_drop = '\0';
1164 PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
1165 }
1166 }
1167 }
1168 wine_tsx11_lock();
1169 if( p_data ) XFree(p_data);
1170 wine_tsx11_unlock();
1171 }
1172
1173 /**********************************************************************
1174 * EVENT_DropURLs
1175 *
1176 * drop items are separated by \n
1177 * each item is prefixed by its mime type
1178 *
1179 * event->data.l[3], event->data.l[4] contains drop x,y position
1180 */
1181 static void EVENT_DropURLs( HWND hWnd, XClientMessageEvent *event )
1182 {
1183 struct x11drv_win_data *win_data;
1184 unsigned long data_length;
1185 unsigned long aux_long, drop_len = 0;
1186 unsigned char *p_data = NULL; /* property data */
1187 char *p_drop = NULL;
1188 char *p, *next;
1189 int x, y;
1190 DROPFILES *lpDrop;
1191 HDROP hDrop;
1192 union {
1193 Atom atom_aux;
1194 int i;
1195 Window w_aux;
1196 unsigned int u;
1197 } u; /* unused */
1198
1199 if (!(GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return;
1200
1201 wine_tsx11_lock();
1202 XGetWindowProperty( event->display, DefaultRootWindow(event->display),
1203 x11drv_atom(DndSelection), 0, 65535, FALSE,
1204 AnyPropertyType, &u.atom_aux, &u.i,
1205 &data_length, &aux_long, &p_data);
1206 wine_tsx11_unlock();
1207 if (aux_long)
1208 WARN("property too large, truncated!\n");
1209 TRACE("urls=%s\n", p_data);
1210
1211 if( !aux_long && p_data) { /* don't bother if > 64K */
1212 /* calculate length */
1213 p = (char*) p_data;
1214 next = strchr(p, '\n');
1215 while (p) {
1216 if (next) *next=0;
1217 if (strncmp(p,"file:",5) == 0 ) {
1218 INT len = GetShortPathNameA( p+5, NULL, 0 );
1219 if (len) drop_len += len + 1;
1220 }
1221 if (next) {
1222 *next = '\n';
1223 p = next + 1;
1224 next = strchr(p, '\n');
1225 } else {
1226 p = NULL;
1227 }
1228 }
1229
1230 if( drop_len && drop_len < 65535 ) {
1231 wine_tsx11_lock();
1232 XQueryPointer( event->display, root_window, &u.w_aux, &u.w_aux,
1233 &x, &y, &u.i, &u.i, &u.u);
1234 x += virtual_screen_rect.left;
1235 y += virtual_screen_rect.top;
1236 wine_tsx11_unlock();
1237
1238 drop_len += sizeof(DROPFILES) + 1;
1239 hDrop = GlobalAlloc( GMEM_SHARE, drop_len );
1240 lpDrop = GlobalLock( hDrop );
1241
1242 if( lpDrop && (win_data = X11DRV_get_win_data( hWnd )))
1243 {
1244 lpDrop->pFiles = sizeof(DROPFILES);
1245 lpDrop->pt.x = x;
1246 lpDrop->pt.y = y;
1247 lpDrop->fNC =
1248 ( x < (win_data->client_rect.left - win_data->whole_rect.left) ||
1249 y < (win_data->client_rect.top - win_data->whole_rect.top) ||
1250 x > (win_data->client_rect.right - win_data->whole_rect.left) ||
1251 y > (win_data->client_rect.bottom - win_data->whole_rect.top) );
1252 lpDrop->fWide = FALSE;
1253 p_drop = (char*)(lpDrop + 1);
1254 }
1255
1256 /* create message content */
1257 if (p_drop) {
1258 p = (char*) p_data;
1259 next = strchr(p, '\n');
1260 while (p) {
1261 if (next) *next=0;
1262 if (strncmp(p,"file:",5) == 0 ) {
1263 INT len = GetShortPathNameA( p+5, p_drop, 65535 );
1264 if (len) {
1265 TRACE("drop file %s as %s\n", p+5, p_drop);
1266 p_drop += len+1;
1267 } else {
1268 WARN("can't convert file %s to dos name\n", p+5);
1269 }
1270 } else {
1271 WARN("unknown mime type %s\n", p);
1272 }
1273 if (next) {
1274 *next = '\n';
1275 p = next + 1;
1276 next = strchr(p, '\n');
1277 } else {
1278 p = NULL;
1279 }
1280 *p_drop = '\0';
1281 }
1282
1283 GlobalUnlock(hDrop);
1284 PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
1285 }
1286 }
1287 wine_tsx11_lock();
1288 if( p_data ) XFree(p_data);
1289 wine_tsx11_unlock();
1290 }
1291 }
1292
1293 /**********************************************************************
1294 * handle_dnd_protocol
1295 */
1296 static void handle_dnd_protocol( HWND hwnd, XClientMessageEvent *event )
1297 {
1298 Window root, child;
1299 int root_x, root_y, child_x, child_y;
1300 unsigned int u;
1301
1302 /* query window (drag&drop event contains only drag window) */
1303 wine_tsx11_lock();
1304 XQueryPointer( event->display, root_window, &root, &child,
1305 &root_x, &root_y, &child_x, &child_y, &u);
1306 if (XFindContext( event->display, child, winContext, (char **)&hwnd ) != 0) hwnd = 0;
1307 wine_tsx11_unlock();
1308 if (!hwnd) return;
1309 if (event->data.l[0] == DndFile || event->data.l[0] == DndFiles)
1310 EVENT_DropFromOffiX(hwnd, event);
1311 else if (event->data.l[0] == DndURL)
1312 EVENT_DropURLs(hwnd, event);
1313 }
1314
1315
1316 struct client_message_handler
1317 {
1318 int atom; /* protocol atom */
1319 void (*handler)(HWND, XClientMessageEvent *); /* corresponding handler function */
1320 };
1321
1322 static const struct client_message_handler client_messages[] =
1323 {
1324 { XATOM_WM_PROTOCOLS, handle_wm_protocols },
1325 { XATOM_DndProtocol, handle_dnd_protocol },
1326 { XATOM_XdndEnter, X11DRV_XDND_EnterEvent },
1327 { XATOM_XdndPosition, X11DRV_XDND_PositionEvent },
1328 { XATOM_XdndDrop, X11DRV_XDND_DropEvent },
1329 { XATOM_XdndLeave, X11DRV_XDND_LeaveEvent }
1330 };
1331
1332
1333 /**********************************************************************
1334 * X11DRV_ClientMessage
1335 */
1336 static void X11DRV_ClientMessage( HWND hwnd, XEvent *xev )
1337 {
1338 XClientMessageEvent *event = &xev->xclient;
1339 unsigned int i;
1340
1341 if (!hwnd) return;
1342
1343 if (event->format != 32)
1344 {
1345 WARN( "Don't know how to handle format %d\n", event->format );
1346 return;
1347 }
1348
1349 for (i = 0; i < sizeof(client_messages)/sizeof(client_messages[0]); i++)
1350 {
1351 if (event->message_type == X11DRV_Atoms[client_messages[i].atom - FIRST_XATOM])
1352 {
1353 client_messages[i].handler( hwnd, event );
1354 return;
1355 }
1356 }
1357 TRACE( "no handler found for %ld\n", event->message_type );
1358 }
1359
1360
1361 /***********************************************************************
1362 * X11DRV_SendInput (X11DRV.@)
1363 */
1364 UINT X11DRV_SendInput( UINT count, LPINPUT inputs, int size )
1365 {
1366 UINT i;
1367
1368 for (i = 0; i < count; i++, inputs++)
1369 {
1370 switch(inputs->type)
1371 {
1372 case INPUT_MOUSE:
1373 X11DRV_send_mouse_input( 0, inputs->u.mi.dwFlags, inputs->u.mi.dx, inputs->u.mi.dy,
1374 inputs->u.mi.mouseData, inputs->u.mi.time,
1375 inputs->u.mi.dwExtraInfo, LLMHF_INJECTED );
1376 break;
1377 case INPUT_KEYBOARD:
1378 X11DRV_send_keyboard_input( inputs->u.ki.wVk, inputs->u.ki.wScan, inputs->u.ki.dwFlags,
1379 inputs->u.ki.time, inputs->u.ki.dwExtraInfo, LLKHF_INJECTED );
1380 break;
1381 case INPUT_HARDWARE:
1382 FIXME( "INPUT_HARDWARE not supported\n" );
1383 break;
1384 }
1385 }
1386 return count;
1387 }
useful hacks and other patches not (yet) suitable for mainline