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