?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 1.1.37.
[wine/gsoc-2012-control.git] / dlls / winex11.drv / event.c
blob63fb5c1094be9347fa603cfa7c7560d81174c2d6
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( "%lu %s for hwnd/window %p/%lx\n",
312 event->xany.serial, 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)(Display*, XEvent*,XPointer), 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 CDECL 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 (style & WS_MINIMIZE) return FALSE;
466 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOACTIVATE) return FALSE;
467 if (hwnd == GetDesktopWindow()) return FALSE;
468 return !(style & WS_DISABLED);
469 }
470
471
472 /**********************************************************************
473 * set_focus
474 */
475 static void set_focus( Display *display, HWND hwnd, Time time )
476 {
477 HWND focus;
478 Window win;
479 GUITHREADINFO threadinfo;
480
481 TRACE( "setting foreground window to %p\n", hwnd );
482 SetForegroundWindow( hwnd );
483
484 GetGUIThreadInfo(0, &threadinfo);
485 focus = threadinfo.hwndFocus;
486 if (focus) focus = GetAncestor( focus, GA_ROOT );
487 win = X11DRV_get_whole_window(focus);
488
489 if (win)
490 {
491 TRACE( "setting focus to %p (%lx) time=%ld\n", focus, win, time );
492 wine_tsx11_lock();
493 XSetInputFocus( display, win, RevertToParent, time );
494 wine_tsx11_unlock();
495 }
496 }
497
498
499 /**********************************************************************
500 * handle_wm_protocols
501 */
502 static void handle_wm_protocols( HWND hwnd, XClientMessageEvent *event )
503 {
504 Atom protocol = (Atom)event->data.l[0];
505
506 if (!protocol) return;
507
508 if (protocol == x11drv_atom(WM_DELETE_WINDOW))
509 {
510 if (hwnd == GetDesktopWindow())
511 {
512 /* The desktop window does not have a close button that we can
513 * pretend to click. Therefore, we simply send it a close command. */
514 SendMessageW(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0);
515 return;
516 }
517
518 /* Ignore the delete window request if the window has been disabled
519 * and we are in managed mode. This is to disallow applications from
520 * being closed by the window manager while in a modal state.
521 */
522 if (IsWindowEnabled(hwnd))
523 {
524 HMENU hSysMenu;
525 POINT pt;
526
527 if (GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE) return;
528 hSysMenu = GetSystemMenu(hwnd, FALSE);
529 if (hSysMenu)
530 {
531 UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
532 if (state == 0xFFFFFFFF || (state & (MF_DISABLED | MF_GRAYED)))
533 return;
534 }
535 if (GetActiveWindow() != hwnd)
536 {
537 LRESULT ma = SendMessageW( hwnd, WM_MOUSEACTIVATE,
538 (WPARAM)GetAncestor( hwnd, GA_ROOT ),
539 MAKELPARAM( HTCLOSE, WM_NCLBUTTONDOWN ) );
540 switch(ma)
541 {
542 case MA_NOACTIVATEANDEAT:
543 case MA_ACTIVATEANDEAT:
544 return;
545 case MA_NOACTIVATE:
546 break;
547 case MA_ACTIVATE:
548 case 0:
549 SetActiveWindow(hwnd);
550 break;
551 default:
552 WARN( "unknown WM_MOUSEACTIVATE code %d\n", (int) ma );
553 break;
554 }
555 }
556 /* Simulate clicking the caption Close button */
557 GetCursorPos( &pt );
558 PostMessageW( hwnd, WM_NCLBUTTONDOWN, HTCLOSE, MAKELPARAM( pt.x, pt.y ) );
559 PostMessageW( hwnd, WM_LBUTTONUP, HTCLOSE, MAKELPARAM( pt.x, pt.y ) );
560 }
561 }
562 else if (protocol == x11drv_atom(WM_TAKE_FOCUS))
563 {
564 Time event_time = (Time)event->data.l[1];
565 HWND last_focus = x11drv_thread_data()->last_focus;
566
567 TRACE( "got take focus msg for %p, enabled=%d, visible=%d (style %08x), focus=%p, active=%p, fg=%p, last=%p\n",
568 hwnd, IsWindowEnabled(hwnd), IsWindowVisible(hwnd), GetWindowLongW(hwnd, GWL_STYLE),
569 GetFocus(), GetActiveWindow(), GetForegroundWindow(), last_focus );
570
571 if (can_activate_window(hwnd))
572 {
573 /* simulate a mouse click on the caption to find out
574 * whether the window wants to be activated */
575 LRESULT ma = SendMessageW( hwnd, WM_MOUSEACTIVATE,
576 (WPARAM)GetAncestor( hwnd, GA_ROOT ),
577 MAKELONG(HTCAPTION,WM_LBUTTONDOWN) );
578 if (ma != MA_NOACTIVATEANDEAT && ma != MA_NOACTIVATE)
579 {
580 set_focus( event->display, hwnd, event_time );
581 return;
582 }
583 }
584 else if (hwnd == GetDesktopWindow())
585 {
586 hwnd = GetForegroundWindow();
587 if (!hwnd) hwnd = last_focus;
588 if (!hwnd) hwnd = GetDesktopWindow();
589 set_focus( event->display, hwnd, event_time );
590 return;
591 }
592 /* try to find some other window to give the focus to */
593 hwnd = GetFocus();
594 if (hwnd) hwnd = GetAncestor( hwnd, GA_ROOT );
595 if (!hwnd) hwnd = GetActiveWindow();
596 if (!hwnd) hwnd = last_focus;
597 if (hwnd && can_activate_window(hwnd)) set_focus( event->display, hwnd, event_time );
598 }
599 else if (protocol == x11drv_atom(_NET_WM_PING))
600 {
601 XClientMessageEvent xev;
602 xev = *event;
603
604 TRACE("NET_WM Ping\n");
605 wine_tsx11_lock();
606 xev.window = DefaultRootWindow(xev.display);
607 XSendEvent(xev.display, xev.window, False, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent*)&xev);
608 wine_tsx11_unlock();
609 /* this line is semi-stolen from gtk2 */
610 TRACE("NET_WM Pong\n");
611 }
612 }
613
614
615 static const char * const focus_details[] =
616 {
617 "NotifyAncestor",
618 "NotifyVirtual",
619 "NotifyInferior",
620 "NotifyNonlinear",
621 "NotifyNonlinearVirtual",
622 "NotifyPointer",
623 "NotifyPointerRoot",
624 "NotifyDetailNone"
625 };
626
627 /**********************************************************************
628 * X11DRV_FocusIn
629 */
630 static void X11DRV_FocusIn( HWND hwnd, XEvent *xev )
631 {
632 XFocusChangeEvent *event = &xev->xfocus;
633 XIC xic;
634
635 if (!hwnd) return;
636
637 TRACE( "win %p xwin %lx detail=%s\n", hwnd, event->window, focus_details[event->detail] );
638
639 if (event->detail == NotifyPointer) return;
640
641 if ((xic = X11DRV_get_ic( hwnd )))
642 {
643 wine_tsx11_lock();
644 XSetICFocus( xic );
645 wine_tsx11_unlock();
646 }
647 if (use_take_focus) return; /* ignore FocusIn if we are using take focus */
648
649 if (!can_activate_window(hwnd))
650 {
651 HWND hwnd = GetFocus();
652 if (hwnd) hwnd = GetAncestor( hwnd, GA_ROOT );
653 if (!hwnd) hwnd = GetActiveWindow();
654 if (!hwnd) hwnd = x11drv_thread_data()->last_focus;
655 if (hwnd && can_activate_window(hwnd)) set_focus( event->display, hwnd, CurrentTime );
656 }
657 else SetForegroundWindow( hwnd );
658 }
659
660
661 /**********************************************************************
662 * X11DRV_FocusOut
663 *
664 * Note: only top-level windows get FocusOut events.
665 */
666 static void X11DRV_FocusOut( HWND hwnd, XEvent *xev )
667 {
668 XFocusChangeEvent *event = &xev->xfocus;
669 HWND hwnd_tmp;
670 Window focus_win;
671 int revert;
672 XIC xic;
673
674 if (!hwnd) return;
675
676 TRACE( "win %p xwin %lx detail=%s\n", hwnd, event->window, focus_details[event->detail] );
677
678 if (event->detail == NotifyPointer) return;
679 if (ximInComposeMode) return;
680
681 x11drv_thread_data()->last_focus = hwnd;
682 if ((xic = X11DRV_get_ic( hwnd )))
683 {
684 wine_tsx11_lock();
685 XUnsetICFocus( xic );
686 wine_tsx11_unlock();
687 }
688 if (hwnd != GetForegroundWindow()) return;
689 if (root_window != DefaultRootWindow(event->display)) return;
690 SendMessageW( hwnd, WM_CANCELMODE, 0, 0 );
691
692 /* don't reset the foreground window, if the window which is
693 getting the focus is a Wine window */
694
695 wine_tsx11_lock();
696 XGetInputFocus( event->display, &focus_win, &revert );
697 if (focus_win)
698 {
699 if (XFindContext( event->display, focus_win, winContext, (char **)&hwnd_tmp ) != 0)
700 focus_win = 0;
701 }
702 wine_tsx11_unlock();
703
704 if (!focus_win)
705 {
706 /* Abey : 6-Oct-99. Check again if the focus out window is the
707 Foreground window, because in most cases the messages sent
708 above must have already changed the foreground window, in which
709 case we don't have to change the foreground window to 0 */
710 if (hwnd == GetForegroundWindow())
711 {
712 TRACE( "lost focus, setting fg to desktop\n" );
713 SetForegroundWindow( GetDesktopWindow() );
714 }
715 }
716 }
717
718
719 /***********************************************************************
720 * X11DRV_Expose
721 */
722 static void X11DRV_Expose( HWND hwnd, XEvent *xev )
723 {
724 XExposeEvent *event = &xev->xexpose;
725 RECT rect;
726 struct x11drv_win_data *data;
727 int flags = RDW_INVALIDATE | RDW_ERASE;
728
729 TRACE( "win %p (%lx) %d,%d %dx%d\n",
730 hwnd, event->window, event->x, event->y, event->width, event->height );
731
732 if (!(data = X11DRV_get_win_data( hwnd ))) return;
733
734 if (event->window == data->whole_window)
735 {
736 rect.left = data->whole_rect.left + event->x;
737 rect.top = data->whole_rect.top + event->y;
738 flags |= RDW_FRAME;
739 }
740 else
741 {
742 rect.left = data->client_rect.left + event->x;
743 rect.top = data->client_rect.top + event->y;
744 }
745 rect.right = rect.left + event->width;
746 rect.bottom = rect.top + event->height;
747
748 if (event->window != root_window)
749 {
750 SERVER_START_REQ( update_window_zorder )
751 {
752 req->window = wine_server_user_handle( hwnd );
753 req->rect.left = rect.left;
754 req->rect.top = rect.top;
755 req->rect.right = rect.right;
756 req->rect.bottom = rect.bottom;
757 wine_server_call( req );
758 }
759 SERVER_END_REQ;
760
761 /* make position relative to client area instead of parent */
762 OffsetRect( &rect, -data->client_rect.left, -data->client_rect.top );
763 flags |= RDW_ALLCHILDREN;
764 }
765
766 RedrawWindow( hwnd, &rect, 0, flags );
767 }
768
769
770 /**********************************************************************
771 * X11DRV_MapNotify
772 */
773 static void X11DRV_MapNotify( HWND hwnd, XEvent *event )
774 {
775 struct x11drv_win_data *data;
776
777 if (!(data = X11DRV_get_win_data( hwnd ))) return;
778 if (!data->mapped) return;
779
780 if (!data->managed)
781 {
782 HWND hwndFocus = GetFocus();
783 if (hwndFocus && IsChild( hwnd, hwndFocus )) X11DRV_SetFocus(hwndFocus); /* FIXME */
784 }
785 }
786
787
788 /***********************************************************************
789 * is_net_wm_state_maximized
790 */
791 static BOOL is_net_wm_state_maximized( Display *display, struct x11drv_win_data *data )
792 {
793 Atom type, *state;
794 int format, ret = 0;
795 unsigned long i, count, remaining;
796
797 wine_tsx11_lock();
798 if (!XGetWindowProperty( display, data->whole_window, x11drv_atom(_NET_WM_STATE), 0,
799 65536/sizeof(CARD32), False, XA_ATOM, &type, &format, &count,
800 &remaining, (unsigned char **)&state ))
801 {
802 if (type == XA_ATOM && format == 32)
803 {
804 for (i = 0; i < count; i++)
805 {
806 if (state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_VERT) ||
807 state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ))
808 ret++;
809 }
810 }
811 XFree( state );
812 }
813 wine_tsx11_unlock();
814 return (ret == 2);
815 }
816
817
818 /***********************************************************************
819 * X11DRV_ConfigureNotify
820 */
821 void X11DRV_ConfigureNotify( HWND hwnd, XEvent *xev )
822 {
823 XConfigureEvent *event = &xev->xconfigure;
824 struct x11drv_win_data *data;
825 RECT rect;
826 UINT flags;
827 int cx, cy, x = event->x, y = event->y;
828
829 if (!hwnd) return;
830 if (!(data = X11DRV_get_win_data( hwnd ))) return;
831 if (!data->mapped || data->iconic || !data->managed) return;
832 if (data->configure_serial && (long)(data->configure_serial - event->serial) > 0)
833 {
834 TRACE( "win %p/%lx event %d,%d,%dx%d ignoring old serial %lu/%lu\n",
835 hwnd, data->whole_window, event->x, event->y, event->width, event->height,
836 event->serial, data->configure_serial );
837 return;
838 }
839
840 /* Get geometry */
841
842 if (!event->send_event) /* normal event, need to map coordinates to the root */
843 {
844 Window child;
845 wine_tsx11_lock();
846 XTranslateCoordinates( event->display, data->whole_window, root_window,
847 0, 0, &x, &y, &child );
848 wine_tsx11_unlock();
849 }
850 rect.left = x;
851 rect.top = y;
852 rect.right = x + event->width;
853 rect.bottom = y + event->height;
854 OffsetRect( &rect, virtual_screen_rect.left, virtual_screen_rect.top );
855 TRACE( "win %p/%lx new X rect %d,%d,%dx%d (event %d,%d,%dx%d)\n",
856 hwnd, data->whole_window, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
857 event->x, event->y, event->width, event->height );
858 X11DRV_X_to_window_rect( data, &rect );
859
860 if (is_net_wm_state_maximized( event->display, data ))
861 {
862 if (!IsZoomed( data->hwnd ))
863 {
864 TRACE( "win %p/%lx is maximized\n", data->hwnd, data->whole_window );
865 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
866 return;
867 }
868 }
869 else
870 {
871 if (IsZoomed( data->hwnd ))
872 {
873 TRACE( "window %p/%lx is no longer maximized\n", data->hwnd, data->whole_window );
874 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0 );
875 return;
876 }
877 }
878
879 /* Compare what has changed */
880
881 x = rect.left;
882 y = rect.top;
883 cx = rect.right - rect.left;
884 cy = rect.bottom - rect.top;
885 flags = SWP_NOACTIVATE | SWP_NOZORDER;
886
887 if (data->window_rect.left == x && data->window_rect.top == y) flags |= SWP_NOMOVE;
888 else
889 TRACE( "%p moving from (%d,%d) to (%d,%d)\n",
890 hwnd, data->window_rect.left, data->window_rect.top, x, y );
891
892 if ((data->window_rect.right - data->window_rect.left == cx &&
893 data->window_rect.bottom - data->window_rect.top == cy) ||
894 (IsRectEmpty( &data->window_rect ) && event->width == 1 && event->height == 1))
895 {
896 if (flags & SWP_NOMOVE) return; /* if nothing changed, don't do anything */
897 flags |= SWP_NOSIZE;
898 }
899 else
900 TRACE( "%p resizing from (%dx%d) to (%dx%d)\n",
901 hwnd, data->window_rect.right - data->window_rect.left,
902 data->window_rect.bottom - data->window_rect.top, cx, cy );
903
904 SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
905 }
906
907
908 /***********************************************************************
909 * get_window_wm_state
910 */
911 static int get_window_wm_state( Display *display, struct x11drv_win_data *data )
912 {
913 struct
914 {
915 CARD32 state;
916 XID icon;
917 } *state;
918 Atom type;
919 int format, ret = -1;
920 unsigned long count, remaining;
921
922 wine_tsx11_lock();
923 if (!XGetWindowProperty( display, data->whole_window, x11drv_atom(WM_STATE), 0,
924 sizeof(*state)/sizeof(CARD32), False, x11drv_atom(WM_STATE),
925 &type, &format, &count, &remaining, (unsigned char **)&state ))
926 {
927 if (type == x11drv_atom(WM_STATE) && get_property_size( format, count ) >= sizeof(*state))
928 ret = state->state;
929 XFree( state );
930 }
931 wine_tsx11_unlock();
932 return ret;
933 }
934
935
936 /***********************************************************************
937 * handle_wm_state_notify
938 *
939 * Handle a PropertyNotify for WM_STATE.
940 */
941 static void handle_wm_state_notify( struct x11drv_win_data *data, XPropertyEvent *event,
942 BOOL update_window )
943 {
944 switch(event->state)
945 {
946 case PropertyDelete:
947 TRACE( "%p/%lx: WM_STATE deleted from %d\n", data->hwnd, data->whole_window, data->wm_state );
948 data->wm_state = WithdrawnState;
949 break;
950 case PropertyNewValue:
951 {
952 int old_state = data->wm_state;
953 int new_state = get_window_wm_state( event->display, data );
954 if (new_state != -1 && new_state != data->wm_state)
955 {
956 TRACE( "%p/%lx: new WM_STATE %d from %d\n",
957 data->hwnd, data->whole_window, new_state, old_state );
958 data->wm_state = new_state;
959 /* ignore the initial state transition out of withdrawn state */
960 /* metacity does Withdrawn->NormalState->IconicState when mapping an iconic window */
961 if (!old_state) return;
962 }
963 }
964 break;
965 }
966
967 if (!update_window || !data->managed || !data->mapped) return;
968
969 if (data->iconic && data->wm_state == NormalState) /* restore window */
970 {
971 data->iconic = FALSE;
972 if (is_net_wm_state_maximized( event->display, data ))
973 {
974 TRACE( "restoring to max %p/%lx\n", data->hwnd, data->whole_window );
975 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
976 }
977 else
978 {
979 TRACE( "restoring win %p/%lx\n", data->hwnd, data->whole_window );
980 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0 );
981 }
982 }
983 else if (!data->iconic && data->wm_state == IconicState)
984 {
985 TRACE( "minimizing win %p/%lx\n", data->hwnd, data->whole_window );
986 data->iconic = TRUE;
987 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0 );
988 }
989 }
990
991
992 /***********************************************************************
993 * X11DRV_PropertyNotify
994 */
995 static void X11DRV_PropertyNotify( HWND hwnd, XEvent *xev )
996 {
997 XPropertyEvent *event = &xev->xproperty;
998 struct x11drv_win_data *data;
999
1000 if (!hwnd) return;
1001 if (!(data = X11DRV_get_win_data( hwnd ))) return;
1002
1003 if (event->atom == x11drv_atom(WM_STATE)) handle_wm_state_notify( data, event, TRUE );
1004 }
1005
1006
1007 /* event filter to wait for a WM_STATE change notification on a window */
1008 static Bool is_wm_state_notify( Display *display, XEvent *event, XPointer arg )
1009 {
1010 if (event->xany.window != (Window)arg) return 0;
1011 return (event->type == DestroyNotify ||
1012 (event->type == PropertyNotify && event->xproperty.atom == x11drv_atom(WM_STATE)));
1013 }
1014
1015 /***********************************************************************
1016 * wait_for_withdrawn_state
1017 */
1018 void wait_for_withdrawn_state( Display *display, struct x11drv_win_data *data, BOOL set )
1019 {
1020 DWORD end = GetTickCount() + 2000;
1021
1022 if (!data->managed) return;
1023
1024 TRACE( "waiting for window %p/%lx to become %swithdrawn\n",
1025 data->hwnd, data->whole_window, set ? "" : "not " );
1026
1027 while (data->whole_window && ((data->wm_state == WithdrawnState) == !set))
1028 {
1029 XEvent event;
1030 int count = 0;
1031
1032 wine_tsx11_lock();
1033 while (XCheckIfEvent( display, &event, is_wm_state_notify, (char *)data->whole_window ))
1034 {
1035 count++;
1036 if (XFilterEvent( &event, None )) continue; /* filtered, ignore it */
1037 if (event.type == DestroyNotify) call_event_handler( display, &event );
1038 else
1039 {
1040 wine_tsx11_unlock();
1041 handle_wm_state_notify( data, &event.xproperty, FALSE );
1042 wine_tsx11_lock();
1043 }
1044 }
1045 wine_tsx11_unlock();
1046
1047 if (!count)
1048 {
1049 struct pollfd pfd;
1050 int timeout = end - GetTickCount();
1051
1052 pfd.fd = ConnectionNumber(display);
1053 pfd.events = POLLIN;
1054 if (timeout <= 0 || poll( &pfd, 1, timeout ) != 1)
1055 {
1056 FIXME( "window %p/%lx wait timed out\n", data->hwnd, data->whole_window );
1057 break;
1058 }
1059 }
1060 }
1061 TRACE( "window %p/%lx state now %d\n", data->hwnd, data->whole_window, data->wm_state );
1062 }
1063
1064
1065 static HWND find_drop_window( HWND hQueryWnd, LPPOINT lpPt )
1066 {
1067 RECT tempRect;
1068
1069 if (!IsWindowEnabled(hQueryWnd)) return 0;
1070
1071 GetWindowRect(hQueryWnd, &tempRect);
1072
1073 if(!PtInRect(&tempRect, *lpPt)) return 0;
1074
1075 if (!IsIconic( hQueryWnd ))
1076 {
1077 POINT pt = *lpPt;
1078 ScreenToClient( hQueryWnd, &pt );
1079 GetClientRect( hQueryWnd, &tempRect );
1080
1081 if (PtInRect( &tempRect, pt))
1082 {
1083 HWND ret = ChildWindowFromPointEx( hQueryWnd, pt, CWP_SKIPINVISIBLE|CWP_SKIPDISABLED );
1084 if (ret && ret != hQueryWnd)
1085 {
1086 ret = find_drop_window( ret, lpPt );
1087 if (ret) return ret;
1088 }
1089 }
1090 }
1091
1092 if(!(GetWindowLongA( hQueryWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return 0;
1093
1094 ScreenToClient(hQueryWnd, lpPt);
1095
1096 return hQueryWnd;
1097 }
1098
1099 /**********************************************************************
1100 * EVENT_DropFromOffix
1101 *
1102 * don't know if it still works (last Changelog is from 96/11/04)
1103 */
1104 static void EVENT_DropFromOffiX( HWND hWnd, XClientMessageEvent *event )
1105 {
1106 struct x11drv_win_data *data;
1107 unsigned long data_length;
1108 unsigned long aux_long;
1109 unsigned char* p_data = NULL;
1110 Atom atom_aux;
1111 int x, y, dummy;
1112 BOOL bAccept;
1113 Window win, w_aux_root, w_aux_child;
1114
1115 win = X11DRV_get_whole_window(hWnd);
1116 wine_tsx11_lock();
1117 XQueryPointer( event->display, win, &w_aux_root, &w_aux_child,
1118 &x, &y, &dummy, &dummy, (unsigned int*)&aux_long);
1119 x += virtual_screen_rect.left;
1120 y += virtual_screen_rect.top;
1121 wine_tsx11_unlock();
1122
1123 if (!(data = X11DRV_get_win_data( hWnd ))) return;
1124
1125 /* find out drop point and drop window */
1126 if( x < 0 || y < 0 ||
1127 x > (data->whole_rect.right - data->whole_rect.left) ||
1128 y > (data->whole_rect.bottom - data->whole_rect.top) )
1129 {
1130 bAccept = GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES;
1131 x = 0;
1132 y = 0;
1133 }
1134 else
1135 {
1136 POINT pt = { x, y };
1137 HWND hwndDrop = find_drop_window( hWnd, &pt );
1138 if (hwndDrop)
1139 {
1140 x = pt.x;
1141 y = pt.y;
1142 bAccept = TRUE;
1143 }
1144 else
1145 {
1146 bAccept = FALSE;
1147 }
1148 }
1149
1150 if (!bAccept) return;
1151
1152 wine_tsx11_lock();
1153 XGetWindowProperty( event->display, DefaultRootWindow(event->display),
1154 x11drv_atom(DndSelection), 0, 65535, FALSE,
1155 AnyPropertyType, &atom_aux, &dummy,
1156 &data_length, &aux_long, &p_data);
1157 wine_tsx11_unlock();
1158
1159 if( !aux_long && p_data) /* don't bother if > 64K */
1160 {
1161 char *p = (char *)p_data;
1162 char *p_drop;
1163
1164 aux_long = 0;
1165 while( *p ) /* calculate buffer size */
1166 {
1167 INT len = GetShortPathNameA( p, NULL, 0 );
1168 if (len) aux_long += len + 1;
1169 p += strlen(p) + 1;
1170 }
1171 if( aux_long && aux_long < 65535 )
1172 {
1173 HDROP hDrop;
1174 DROPFILES *lpDrop;
1175
1176 aux_long += sizeof(DROPFILES) + 1;
1177 hDrop = GlobalAlloc( GMEM_SHARE, aux_long );
1178 lpDrop = GlobalLock( hDrop );
1179
1180 if( lpDrop )
1181 {
1182 lpDrop->pFiles = sizeof(DROPFILES);
1183 lpDrop->pt.x = x;
1184 lpDrop->pt.y = y;
1185 lpDrop->fNC = FALSE;
1186 lpDrop->fWide = FALSE;
1187 p_drop = (char *)(lpDrop + 1);
1188 p = (char *)p_data;
1189 while(*p)
1190 {
1191 if (GetShortPathNameA( p, p_drop, aux_long - (p_drop - (char *)lpDrop) ))
1192 p_drop += strlen( p_drop ) + 1;
1193 p += strlen(p) + 1;
1194 }
1195 *p_drop = '\0';
1196 PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
1197 }
1198 }
1199 }
1200 wine_tsx11_lock();
1201 if( p_data ) XFree(p_data);
1202 wine_tsx11_unlock();
1203 }
1204
1205 /**********************************************************************
1206 * EVENT_DropURLs
1207 *
1208 * drop items are separated by \n
1209 * each item is prefixed by its mime type
1210 *
1211 * event->data.l[3], event->data.l[4] contains drop x,y position
1212 */
1213 static void EVENT_DropURLs( HWND hWnd, XClientMessageEvent *event )
1214 {
1215 struct x11drv_win_data *win_data;
1216 unsigned long data_length;
1217 unsigned long aux_long, drop_len = 0;
1218 unsigned char *p_data = NULL; /* property data */
1219 char *p_drop = NULL;
1220 char *p, *next;
1221 int x, y;
1222 DROPFILES *lpDrop;
1223 HDROP hDrop;
1224 union {
1225 Atom atom_aux;
1226 int i;
1227 Window w_aux;
1228 unsigned int u;
1229 } u; /* unused */
1230
1231 if (!(GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return;
1232
1233 wine_tsx11_lock();
1234 XGetWindowProperty( event->display, DefaultRootWindow(event->display),
1235 x11drv_atom(DndSelection), 0, 65535, FALSE,
1236 AnyPropertyType, &u.atom_aux, &u.i,
1237 &data_length, &aux_long, &p_data);
1238 wine_tsx11_unlock();
1239 if (aux_long)
1240 WARN("property too large, truncated!\n");
1241 TRACE("urls=%s\n", p_data);
1242
1243 if( !aux_long && p_data) { /* don't bother if > 64K */
1244 /* calculate length */
1245 p = (char*) p_data;
1246 next = strchr(p, '\n');
1247 while (p) {
1248 if (next) *next=0;
1249 if (strncmp(p,"file:",5) == 0 ) {
1250 INT len = GetShortPathNameA( p+5, NULL, 0 );
1251 if (len) drop_len += len + 1;
1252 }
1253 if (next) {
1254 *next = '\n';
1255 p = next + 1;
1256 next = strchr(p, '\n');
1257 } else {
1258 p = NULL;
1259 }
1260 }
1261
1262 if( drop_len && drop_len < 65535 ) {
1263 wine_tsx11_lock();
1264 XQueryPointer( event->display, root_window, &u.w_aux, &u.w_aux,
1265 &x, &y, &u.i, &u.i, &u.u);
1266 x += virtual_screen_rect.left;
1267 y += virtual_screen_rect.top;
1268 wine_tsx11_unlock();
1269
1270 drop_len += sizeof(DROPFILES) + 1;
1271 hDrop = GlobalAlloc( GMEM_SHARE, drop_len );
1272 lpDrop = GlobalLock( hDrop );
1273
1274 if( lpDrop && (win_data = X11DRV_get_win_data( hWnd )))
1275 {
1276 lpDrop->pFiles = sizeof(DROPFILES);
1277 lpDrop->pt.x = x;
1278 lpDrop->pt.y = y;
1279 lpDrop->fNC =
1280 ( x < (win_data->client_rect.left - win_data->whole_rect.left) ||
1281 y < (win_data->client_rect.top - win_data->whole_rect.top) ||
1282 x > (win_data->client_rect.right - win_data->whole_rect.left) ||
1283 y > (win_data->client_rect.bottom - win_data->whole_rect.top) );
1284 lpDrop->fWide = FALSE;
1285 p_drop = (char*)(lpDrop + 1);
1286 }
1287
1288 /* create message content */
1289 if (p_drop) {
1290 p = (char*) p_data;
1291 next = strchr(p, '\n');
1292 while (p) {
1293 if (next) *next=0;
1294 if (strncmp(p,"file:",5) == 0 ) {
1295 INT len = GetShortPathNameA( p+5, p_drop, 65535 );
1296 if (len) {
1297 TRACE("drop file %s as %s\n", p+5, p_drop);
1298 p_drop += len+1;
1299 } else {
1300 WARN("can't convert file %s to dos name\n", p+5);
1301 }
1302 } else {
1303 WARN("unknown mime type %s\n", p);
1304 }
1305 if (next) {
1306 *next = '\n';
1307 p = next + 1;
1308 next = strchr(p, '\n');
1309 } else {
1310 p = NULL;
1311 }
1312 *p_drop = '\0';
1313 }
1314
1315 GlobalUnlock(hDrop);
1316 PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
1317 }
1318 }
1319 wine_tsx11_lock();
1320 if( p_data ) XFree(p_data);
1321 wine_tsx11_unlock();
1322 }
1323 }
1324
1325 /**********************************************************************
1326 * handle_dnd_protocol
1327 */
1328 static void handle_dnd_protocol( HWND hwnd, XClientMessageEvent *event )
1329 {
1330 Window root, child;
1331 int root_x, root_y, child_x, child_y;
1332 unsigned int u;
1333
1334 /* query window (drag&drop event contains only drag window) */
1335 wine_tsx11_lock();
1336 XQueryPointer( event->display, root_window, &root, &child,
1337 &root_x, &root_y, &child_x, &child_y, &u);
1338 if (XFindContext( event->display, child, winContext, (char **)&hwnd ) != 0) hwnd = 0;
1339 wine_tsx11_unlock();
1340 if (!hwnd) return;
1341 if (event->data.l[0] == DndFile || event->data.l[0] == DndFiles)
1342 EVENT_DropFromOffiX(hwnd, event);
1343 else if (event->data.l[0] == DndURL)
1344 EVENT_DropURLs(hwnd, event);
1345 }
1346
1347
1348 struct client_message_handler
1349 {
1350 int atom; /* protocol atom */
1351 void (*handler)(HWND, XClientMessageEvent *); /* corresponding handler function */
1352 };
1353
1354 static const struct client_message_handler client_messages[] =
1355 {
1356 { XATOM_WM_PROTOCOLS, handle_wm_protocols },
1357 { XATOM_DndProtocol, handle_dnd_protocol },
1358 { XATOM_XdndEnter, X11DRV_XDND_EnterEvent },
1359 { XATOM_XdndPosition, X11DRV_XDND_PositionEvent },
1360 { XATOM_XdndDrop, X11DRV_XDND_DropEvent },
1361 { XATOM_XdndLeave, X11DRV_XDND_LeaveEvent }
1362 };
1363
1364
1365 /**********************************************************************
1366 * X11DRV_ClientMessage
1367 */
1368 static void X11DRV_ClientMessage( HWND hwnd, XEvent *xev )
1369 {
1370 XClientMessageEvent *event = &xev->xclient;
1371 unsigned int i;
1372
1373 if (!hwnd) return;
1374
1375 if (event->format != 32)
1376 {
1377 WARN( "Don't know how to handle format %d\n", event->format );
1378 return;
1379 }
1380
1381 for (i = 0; i < sizeof(client_messages)/sizeof(client_messages[0]); i++)
1382 {
1383 if (event->message_type == X11DRV_Atoms[client_messages[i].atom - FIRST_XATOM])
1384 {
1385 client_messages[i].handler( hwnd, event );
1386 return;
1387 }
1388 }
1389 TRACE( "no handler found for %ld\n", event->message_type );
1390 }
1391
1392
1393 /***********************************************************************
1394 * X11DRV_SendInput (X11DRV.@)
1395 */
1396 UINT CDECL X11DRV_SendInput( UINT count, LPINPUT inputs, int size )
1397 {
1398 UINT i;
1399
1400 for (i = 0; i < count; i++, inputs++)
1401 {
1402 switch(inputs->type)
1403 {
1404 case INPUT_MOUSE:
1405 X11DRV_send_mouse_input( 0, inputs->u.mi.dwFlags, inputs->u.mi.dx, inputs->u.mi.dy,
1406 inputs->u.mi.mouseData, inputs->u.mi.time,
1407 inputs->u.mi.dwExtraInfo, LLMHF_INJECTED );
1408 break;
1409 case INPUT_KEYBOARD:
1410 X11DRV_send_keyboard_input( inputs->u.ki.wVk, inputs->u.ki.wScan, inputs->u.ki.dwFlags,
1411 inputs->u.ki.time, inputs->u.ki.dwExtraInfo, LLKHF_INJECTED );
1412 break;
1413 case INPUT_HARDWARE:
1414 FIXME( "INPUT_HARDWARE not supported\n" );
1415 break;
1416 }
1417 }
1418 return count;
1419 }
GSOC 2012 project to enhance the control panel