4 * Copyright 1993 Alexandre Julliard
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.
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.
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
27 #ifdef HAVE_SYS_POLL_H
30 #include <X11/Xatom.h>
31 #include <X11/keysym.h>
33 #include <X11/Xresource.h>
34 #include <X11/Xutil.h>
35 #ifdef HAVE_X11_EXTENSIONS_XINPUT2_H
36 #include <X11/extensions/XInput2.h>
43 #define NONAMELESSUNION
44 #define NONAMELESSSTRUCT
52 /* avoid conflict with field names in included win32 headers */
54 #include "shlobj.h" /* DROPFILES */
57 #include "wine/server.h"
58 #include "wine/debug.h"
60 WINE_DEFAULT_DEBUG_CHANNEL(event
);
62 extern BOOL ximInComposeMode
;
64 #define DndNotDnd -1 /* OffiX drag&drop */
76 #define DndURL 128 /* KDE drag&drop */
78 #define XEMBED_EMBEDDED_NOTIFY 0
79 #define XEMBED_WINDOW_ACTIVATE 1
80 #define XEMBED_WINDOW_DEACTIVATE 2
81 #define XEMBED_REQUEST_FOCUS 3
82 #define XEMBED_FOCUS_IN 4
83 #define XEMBED_FOCUS_OUT 5
84 #define XEMBED_FOCUS_NEXT 6
85 #define XEMBED_FOCUS_PREV 7
86 #define XEMBED_MODALITY_ON 10
87 #define XEMBED_MODALITY_OFF 11
88 #define XEMBED_REGISTER_ACCELERATOR 12
89 #define XEMBED_UNREGISTER_ACCELERATOR 13
90 #define XEMBED_ACTIVATE_ACCELERATOR 14
92 Bool (*pXGetEventData
)( Display
*display
, XEvent
/*XGenericEventCookie*/ *event
) = NULL
;
93 void (*pXFreeEventData
)( Display
*display
, XEvent
/*XGenericEventCookie*/ *event
) = NULL
;
96 static void X11DRV_FocusIn( HWND hwnd
, XEvent
*event
);
97 static void X11DRV_FocusOut( HWND hwnd
, XEvent
*event
);
98 static void X11DRV_Expose( HWND hwnd
, XEvent
*event
);
99 static void X11DRV_MapNotify( HWND hwnd
, XEvent
*event
);
100 static void X11DRV_UnmapNotify( HWND hwnd
, XEvent
*event
);
101 static void X11DRV_ReparentNotify( HWND hwnd
, XEvent
*event
);
102 static void X11DRV_ConfigureNotify( HWND hwnd
, XEvent
*event
);
103 static void X11DRV_PropertyNotify( HWND hwnd
, XEvent
*event
);
104 static void X11DRV_ClientMessage( HWND hwnd
, XEvent
*event
);
105 static void X11DRV_GravityNotify( HWND hwnd
, XEvent
*event
);
107 #define MAX_EVENT_HANDLERS 128
109 static x11drv_event_handler handlers
[MAX_EVENT_HANDLERS
] =
111 NULL
, /* 0 reserved */
112 NULL
, /* 1 reserved */
113 X11DRV_KeyEvent
, /* 2 KeyPress */
114 X11DRV_KeyEvent
, /* 3 KeyRelease */
115 X11DRV_ButtonPress
, /* 4 ButtonPress */
116 X11DRV_ButtonRelease
, /* 5 ButtonRelease */
117 X11DRV_MotionNotify
, /* 6 MotionNotify */
118 X11DRV_EnterNotify
, /* 7 EnterNotify */
119 NULL
, /* 8 LeaveNotify */
120 X11DRV_FocusIn
, /* 9 FocusIn */
121 X11DRV_FocusOut
, /* 10 FocusOut */
122 X11DRV_KeymapNotify
, /* 11 KeymapNotify */
123 X11DRV_Expose
, /* 12 Expose */
124 NULL
, /* 13 GraphicsExpose */
125 NULL
, /* 14 NoExpose */
126 NULL
, /* 15 VisibilityNotify */
127 NULL
, /* 16 CreateNotify */
128 X11DRV_DestroyNotify
, /* 17 DestroyNotify */
129 X11DRV_UnmapNotify
, /* 18 UnmapNotify */
130 X11DRV_MapNotify
, /* 19 MapNotify */
131 NULL
, /* 20 MapRequest */
132 X11DRV_ReparentNotify
, /* 21 ReparentNotify */
133 X11DRV_ConfigureNotify
, /* 22 ConfigureNotify */
134 NULL
, /* 23 ConfigureRequest */
135 X11DRV_GravityNotify
, /* 24 GravityNotify */
136 NULL
, /* 25 ResizeRequest */
137 NULL
, /* 26 CirculateNotify */
138 NULL
, /* 27 CirculateRequest */
139 X11DRV_PropertyNotify
, /* 28 PropertyNotify */
140 X11DRV_SelectionClear
, /* 29 SelectionClear */
141 X11DRV_SelectionRequest
, /* 30 SelectionRequest */
142 NULL
, /* 31 SelectionNotify */
143 NULL
, /* 32 ColormapNotify */
144 X11DRV_ClientMessage
, /* 33 ClientMessage */
145 X11DRV_MappingNotify
, /* 34 MappingNotify */
146 X11DRV_GenericEvent
/* 35 GenericEvent */
149 static const char * event_names
[MAX_EVENT_HANDLERS
] =
151 NULL
, NULL
, "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease",
152 "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut",
153 "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify",
154 "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",
155 "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify", "ResizeRequest",
156 "CirculateNotify", "CirculateRequest", "PropertyNotify", "SelectionClear", "SelectionRequest",
157 "SelectionNotify", "ColormapNotify", "ClientMessage", "MappingNotify", "GenericEvent"
160 int xinput2_opcode
= 0;
162 /* return the name of an X event */
163 static const char *dbgstr_event( int type
)
165 if (type
< MAX_EVENT_HANDLERS
&& event_names
[type
]) return event_names
[type
];
166 return wine_dbg_sprintf( "Unknown event %d", type
);
169 static inline void get_event_data( XEvent
*event
)
171 #if defined(GenericEvent) && defined(HAVE_XEVENT_XCOOKIE)
172 if (event
->xany
.type
!= GenericEvent
) return;
173 if (!pXGetEventData
|| !pXGetEventData( event
->xany
.display
, event
)) event
->xcookie
.data
= NULL
;
177 static inline void free_event_data( XEvent
*event
)
179 #if defined(GenericEvent) && defined(HAVE_XEVENT_XCOOKIE)
180 if (event
->xany
.type
!= GenericEvent
) return;
181 if (event
->xcookie
.data
) pXFreeEventData( event
->xany
.display
, event
);
185 /***********************************************************************
186 * X11DRV_register_event_handler
188 * Register a handler for a given event type.
189 * If already registered, overwrite the previous handler.
191 void X11DRV_register_event_handler( int type
, x11drv_event_handler handler
, const char *name
)
193 assert( type
< MAX_EVENT_HANDLERS
);
194 assert( !handlers
[type
] || handlers
[type
] == handler
);
195 handlers
[type
] = handler
;
196 event_names
[type
] = name
;
197 TRACE("registered handler %p for event %d %s\n", handler
, type
, debugstr_a(name
) );
201 /***********************************************************************
204 static Bool
filter_event( Display
*display
, XEvent
*event
, char *arg
)
206 ULONG_PTR mask
= (ULONG_PTR
)arg
;
208 if ((mask
& QS_ALLINPUT
) == QS_ALLINPUT
) return 1;
216 return (mask
& (QS_KEY
|QS_HOTKEY
)) != 0;
219 return (mask
& QS_MOUSEBUTTON
) != 0;
223 return (mask
& QS_MOUSEMOVE
) != 0;
225 return (mask
& QS_PAINT
) != 0;
230 case ConfigureNotify
:
233 return (mask
& QS_POSTMESSAGE
) != 0;
235 return (mask
& QS_SENDMESSAGE
) != 0;
240 enum event_merge_action
242 MERGE_DISCARD
, /* discard the old event */
243 MERGE_HANDLE
, /* handle the old event */
244 MERGE_KEEP
, /* keep the old event for future merging */
245 MERGE_IGNORE
/* ignore the new event, keep the old one */
248 /***********************************************************************
249 * merge_raw_motion_events
251 #ifdef HAVE_X11_EXTENSIONS_XINPUT2_H
252 static enum event_merge_action
merge_raw_motion_events( XIRawEvent
*prev
, XIRawEvent
*next
)
257 if (!prev
->valuators
.mask_len
) return MERGE_HANDLE
;
258 if (!next
->valuators
.mask_len
) return MERGE_HANDLE
;
260 mask
= prev
->valuators
.mask
[0] | next
->valuators
.mask
[0];
261 if (mask
== next
->valuators
.mask
[0]) /* keep next */
263 for (i
= j
= k
= 0; i
< 8; i
++)
265 if (XIMaskIsSet( prev
->valuators
.mask
, i
))
266 next
->valuators
.values
[j
] += prev
->valuators
.values
[k
++];
267 if (XIMaskIsSet( next
->valuators
.mask
, i
)) j
++;
269 TRACE( "merging duplicate GenericEvent\n" );
270 return MERGE_DISCARD
;
272 if (mask
== prev
->valuators
.mask
[0]) /* keep prev */
274 for (i
= j
= k
= 0; i
< 8; i
++)
276 if (XIMaskIsSet( next
->valuators
.mask
, i
))
277 prev
->valuators
.values
[j
] += next
->valuators
.values
[k
++];
278 if (XIMaskIsSet( prev
->valuators
.mask
, i
)) j
++;
280 TRACE( "merging duplicate GenericEvent\n" );
283 /* can't merge events with disjoint masks */
288 /***********************************************************************
291 * Try to merge 2 consecutive events.
293 static enum event_merge_action
merge_events( XEvent
*prev
, XEvent
*next
)
297 case ConfigureNotify
:
300 case ConfigureNotify
:
301 if (prev
->xany
.window
== next
->xany
.window
)
303 TRACE( "discarding duplicate ConfigureNotify for window %lx\n", prev
->xany
.window
);
304 return MERGE_DISCARD
;
316 if (prev
->xany
.window
== next
->xany
.window
)
318 TRACE( "discarding duplicate MotionNotify for window %lx\n", prev
->xany
.window
);
319 return MERGE_DISCARD
;
322 #ifdef HAVE_X11_EXTENSIONS_XINPUT2_H
324 if (next
->xcookie
.extension
!= xinput2_opcode
) break;
325 if (next
->xcookie
.evtype
!= XI_RawMotion
) break;
326 if (x11drv_thread_data()->warp_serial
) break;
331 if (prev
->xcookie
.extension
!= xinput2_opcode
) break;
332 if (prev
->xcookie
.evtype
!= XI_RawMotion
) break;
336 if (next
->xcookie
.extension
!= xinput2_opcode
) break;
337 if (next
->xcookie
.evtype
!= XI_RawMotion
) break;
338 if (x11drv_thread_data()->warp_serial
) break;
339 return merge_raw_motion_events( prev
->xcookie
.data
, next
->xcookie
.data
);
348 /***********************************************************************
351 static inline void call_event_handler( Display
*display
, XEvent
*event
)
355 struct x11drv_thread_data
*thread_data
;
357 if (!handlers
[event
->type
])
359 TRACE( "%s for win %lx, ignoring\n", dbgstr_event( event
->type
), event
->xany
.window
);
360 return; /* no handler, ignore it */
363 if (XFindContext( display
, event
->xany
.window
, winContext
, (char **)&hwnd
) != 0)
364 hwnd
= 0; /* not for a registered window */
365 if (!hwnd
&& event
->xany
.window
== root_window
) hwnd
= GetDesktopWindow();
367 TRACE( "%lu %s for hwnd/window %p/%lx\n",
368 event
->xany
.serial
, dbgstr_event( event
->type
), hwnd
, event
->xany
.window
);
369 thread_data
= x11drv_thread_data();
370 prev
= thread_data
->current_event
;
371 thread_data
->current_event
= event
;
372 handlers
[event
->type
]( hwnd
, event
);
373 thread_data
->current_event
= prev
;
377 /***********************************************************************
380 static int process_events( Display
*display
, Bool (*filter
)(Display
*, XEvent
*,XPointer
), ULONG_PTR arg
)
382 XEvent event
, prev_event
;
384 enum event_merge_action action
= MERGE_DISCARD
;
387 while (XCheckIfEvent( display
, &event
, filter
, (char *)arg
))
390 if (XFilterEvent( &event
, None
))
393 * SCIM on linux filters key events strangely. It does not filter the
394 * KeyPress events for these keys however it does filter the
395 * KeyRelease events. This causes wine to become very confused as
396 * to the keyboard state.
398 * We need to let those KeyRelease events be processed so that the
399 * keyboard state is correct.
401 if (event
.type
== KeyRelease
)
404 XKeyEvent
*keyevent
= &event
.xkey
;
406 XLookupString(keyevent
, NULL
, 0, &keysym
, NULL
);
407 if (!(keysym
== XK_Shift_L
||
408 keysym
== XK_Shift_R
||
409 keysym
== XK_Control_L
||
410 keysym
== XK_Control_R
||
411 keysym
== XK_Alt_R
||
412 keysym
== XK_Alt_L
||
413 keysym
== XK_Meta_R
||
414 keysym
== XK_Meta_L
))
415 continue; /* not a key we care about, ignore it */
418 continue; /* filtered, ignore it */
420 get_event_data( &event
);
421 if (prev_event
.type
) action
= merge_events( &prev_event
, &event
);
424 case MERGE_HANDLE
: /* handle prev, keep new */
425 call_event_handler( display
, &prev_event
);
427 case MERGE_DISCARD
: /* discard prev, keep new */
428 free_event_data( &prev_event
);
431 case MERGE_KEEP
: /* handle new, keep prev for future merging */
432 call_event_handler( display
, &event
);
434 case MERGE_IGNORE
: /* ignore new, keep prev for future merging */
435 free_event_data( &event
);
439 if (prev_event
.type
) call_event_handler( display
, &prev_event
);
440 free_event_data( &prev_event
);
441 XFlush( gdi_display
);
442 if (count
) TRACE( "processed %d events\n", count
);
447 /***********************************************************************
448 * MsgWaitForMultipleObjectsEx (X11DRV.@)
450 DWORD CDECL
X11DRV_MsgWaitForMultipleObjectsEx( DWORD count
, const HANDLE
*handles
,
451 DWORD timeout
, DWORD mask
, DWORD flags
)
454 struct x11drv_thread_data
*data
= TlsGetValue( thread_data_tls_index
);
458 if (!count
&& !timeout
) return WAIT_TIMEOUT
;
459 return WaitForMultipleObjectsEx( count
, handles
, flags
& MWMO_WAITALL
,
460 timeout
, flags
& MWMO_ALERTABLE
);
463 if (data
->current_event
) mask
= 0; /* don't process nested events */
465 if (process_events( data
->display
, filter_event
, mask
)) ret
= count
- 1;
466 else if (count
|| timeout
)
468 ret
= WaitForMultipleObjectsEx( count
, handles
, flags
& MWMO_WAITALL
,
469 timeout
, flags
& MWMO_ALERTABLE
);
470 if (ret
== count
- 1) process_events( data
->display
, filter_event
, mask
);
472 else ret
= WAIT_TIMEOUT
;
477 /***********************************************************************
478 * EVENT_x11_time_to_win32_time
480 * Make our timer and the X timer line up as best we can
481 * Pass 0 to retrieve the current adjustment value (times -1)
483 DWORD
EVENT_x11_time_to_win32_time(Time time
)
485 static DWORD adjust
= 0;
486 DWORD now
= GetTickCount();
489 if (! adjust
&& time
!= 0)
496 /* If we got an event in the 'future', then our clock is clearly wrong.
497 If we got it more than 10000 ms in the future, then it's most likely
498 that the clock has wrapped. */
501 if (ret
> now
&& ((ret
- now
) < 10000) && time
!= 0)
512 /*******************************************************************
513 * can_activate_window
515 * Check if we can activate the specified window.
517 static inline BOOL
can_activate_window( HWND hwnd
)
519 LONG style
= GetWindowLongW( hwnd
, GWL_STYLE
);
522 if (!(style
& WS_VISIBLE
)) return FALSE
;
523 if ((style
& (WS_POPUP
|WS_CHILD
)) == WS_CHILD
) return FALSE
;
524 if (style
& WS_MINIMIZE
) return FALSE
;
525 if (GetWindowLongW( hwnd
, GWL_EXSTYLE
) & WS_EX_NOACTIVATE
) return FALSE
;
526 if (hwnd
== GetDesktopWindow()) return FALSE
;
527 if (GetWindowRect( hwnd
, &rect
) && IsRectEmpty( &rect
)) return FALSE
;
528 return !(style
& WS_DISABLED
);
532 /**********************************************************************
535 * Try to force focus for non-managed windows.
537 static void set_input_focus( Display
*display
, Window window
)
539 XWindowChanges changes
;
544 if (EVENT_x11_time_to_win32_time(0))
545 /* ICCCM says don't use CurrentTime, so try to use last message time if possible */
546 /* FIXME: this is not entirely correct */
547 timestamp
= GetMessageTime() - EVENT_x11_time_to_win32_time(0);
549 timestamp
= CurrentTime
;
551 /* Set X focus and install colormap */
552 changes
.stack_mode
= Above
;
553 XConfigureWindow( display
, window
, CWStackMode
, &changes
);
554 XSetInputFocus( display
, window
, RevertToParent
, timestamp
);
557 /**********************************************************************
560 static void set_focus( Display
*display
, HWND hwnd
, Time time
)
564 GUITHREADINFO threadinfo
;
566 TRACE( "setting foreground window to %p\n", hwnd
);
567 SetForegroundWindow( hwnd
);
569 threadinfo
.cbSize
= sizeof(threadinfo
);
570 GetGUIThreadInfo(0, &threadinfo
);
571 focus
= threadinfo
.hwndFocus
;
572 if (!focus
) focus
= threadinfo
.hwndActive
;
573 if (focus
) focus
= GetAncestor( focus
, GA_ROOT
);
574 win
= X11DRV_get_whole_window(focus
);
578 TRACE( "setting focus to %p (%lx) time=%ld\n", focus
, win
, time
);
579 XSetInputFocus( display
, win
, RevertToParent
, time
);
584 /**********************************************************************
585 * handle_manager_message
587 static void handle_manager_message( HWND hwnd
, XClientMessageEvent
*event
)
589 if (hwnd
!= GetDesktopWindow()) return;
590 if (systray_atom
&& event
->data
.l
[1] == systray_atom
)
591 change_systray_owner( event
->display
, event
->data
.l
[2] );
595 /**********************************************************************
596 * handle_wm_protocols
598 static void handle_wm_protocols( HWND hwnd
, XClientMessageEvent
*event
)
600 Atom protocol
= (Atom
)event
->data
.l
[0];
601 Time event_time
= (Time
)event
->data
.l
[1];
603 if (!protocol
) return;
605 if (protocol
== x11drv_atom(WM_DELETE_WINDOW
))
607 update_user_time( event_time
);
609 if (hwnd
== GetDesktopWindow())
611 /* The desktop window does not have a close button that we can
612 * pretend to click. Therefore, we simply send it a close command. */
613 SendMessageW(hwnd
, WM_SYSCOMMAND
, SC_CLOSE
, 0);
617 /* Ignore the delete window request if the window has been disabled
618 * and we are in managed mode. This is to disallow applications from
619 * being closed by the window manager while in a modal state.
621 if (IsWindowEnabled(hwnd
))
625 if (GetClassLongW(hwnd
, GCL_STYLE
) & CS_NOCLOSE
) return;
626 hSysMenu
= GetSystemMenu(hwnd
, FALSE
);
629 UINT state
= GetMenuState(hSysMenu
, SC_CLOSE
, MF_BYCOMMAND
);
630 if (state
== 0xFFFFFFFF || (state
& (MF_DISABLED
| MF_GRAYED
)))
633 if (GetActiveWindow() != hwnd
)
635 LRESULT ma
= SendMessageW( hwnd
, WM_MOUSEACTIVATE
,
636 (WPARAM
)GetAncestor( hwnd
, GA_ROOT
),
637 MAKELPARAM( HTCLOSE
, WM_NCLBUTTONDOWN
) );
640 case MA_NOACTIVATEANDEAT
:
641 case MA_ACTIVATEANDEAT
:
647 SetActiveWindow(hwnd
);
650 WARN( "unknown WM_MOUSEACTIVATE code %d\n", (int) ma
);
655 PostMessageW( hwnd
, WM_SYSCOMMAND
, SC_CLOSE
, 0 );
658 else if (protocol
== x11drv_atom(WM_TAKE_FOCUS
))
660 HWND last_focus
= x11drv_thread_data()->last_focus
;
662 TRACE( "got take focus msg for %p, enabled=%d, visible=%d (style %08x), focus=%p, active=%p, fg=%p, last=%p\n",
663 hwnd
, IsWindowEnabled(hwnd
), IsWindowVisible(hwnd
), GetWindowLongW(hwnd
, GWL_STYLE
),
664 GetFocus(), GetActiveWindow(), GetForegroundWindow(), last_focus
);
666 if (can_activate_window(hwnd
))
668 /* simulate a mouse click on the caption to find out
669 * whether the window wants to be activated */
670 LRESULT ma
= SendMessageW( hwnd
, WM_MOUSEACTIVATE
,
671 (WPARAM
)GetAncestor( hwnd
, GA_ROOT
),
672 MAKELONG(HTCAPTION
,WM_LBUTTONDOWN
) );
673 if (ma
!= MA_NOACTIVATEANDEAT
&& ma
!= MA_NOACTIVATE
)
675 set_focus( event
->display
, hwnd
, event_time
);
679 else if (hwnd
== GetDesktopWindow())
681 hwnd
= GetForegroundWindow();
682 if (!hwnd
) hwnd
= last_focus
;
683 if (!hwnd
) hwnd
= GetDesktopWindow();
684 set_focus( event
->display
, hwnd
, event_time
);
687 /* try to find some other window to give the focus to */
689 if (hwnd
) hwnd
= GetAncestor( hwnd
, GA_ROOT
);
690 if (!hwnd
) hwnd
= GetActiveWindow();
691 if (!hwnd
) hwnd
= last_focus
;
692 if (hwnd
&& can_activate_window(hwnd
)) set_focus( event
->display
, hwnd
, event_time
);
694 else if (protocol
== x11drv_atom(_NET_WM_PING
))
696 XClientMessageEvent xev
;
699 TRACE("NET_WM Ping\n");
700 xev
.window
= DefaultRootWindow(xev
.display
);
701 XSendEvent(xev
.display
, xev
.window
, False
, SubstructureRedirectMask
| SubstructureNotifyMask
, (XEvent
*)&xev
);
706 static const char * const focus_details
[] =
712 "NotifyNonlinearVirtual",
718 /**********************************************************************
721 static void X11DRV_FocusIn( HWND hwnd
, XEvent
*xev
)
723 XFocusChangeEvent
*event
= &xev
->xfocus
;
728 TRACE( "win %p xwin %lx detail=%s\n", hwnd
, event
->window
, focus_details
[event
->detail
] );
730 if (event
->detail
== NotifyPointer
) return;
731 if (hwnd
== GetDesktopWindow()) return;
733 if ((xic
= X11DRV_get_ic( hwnd
))) XSetICFocus( xic
);
736 if (hwnd
== GetForegroundWindow()) clip_fullscreen_window( hwnd
, FALSE
);
740 if (!can_activate_window(hwnd
))
742 HWND hwnd
= GetFocus();
743 if (hwnd
) hwnd
= GetAncestor( hwnd
, GA_ROOT
);
744 if (!hwnd
) hwnd
= GetActiveWindow();
745 if (!hwnd
) hwnd
= x11drv_thread_data()->last_focus
;
746 if (hwnd
&& can_activate_window(hwnd
)) set_focus( event
->display
, hwnd
, CurrentTime
);
748 else SetForegroundWindow( hwnd
);
752 /**********************************************************************
755 * Note: only top-level windows get FocusOut events.
757 static void X11DRV_FocusOut( HWND hwnd
, XEvent
*xev
)
759 XFocusChangeEvent
*event
= &xev
->xfocus
;
765 TRACE( "win %p xwin %lx detail=%s\n", hwnd
, event
->window
, focus_details
[event
->detail
] );
767 if (event
->detail
== NotifyPointer
)
769 if (!hwnd
&& event
->window
== x11drv_thread_data()->clip_window
) reset_clipping_window();
773 if (ximInComposeMode
) return;
775 x11drv_thread_data()->last_focus
= hwnd
;
776 if ((xic
= X11DRV_get_ic( hwnd
))) XUnsetICFocus( xic
);
778 if (root_window
!= DefaultRootWindow(event
->display
))
780 if (hwnd
== GetDesktopWindow()) reset_clipping_window();
783 if (hwnd
!= GetForegroundWindow()) return;
784 SendMessageW( hwnd
, WM_CANCELMODE
, 0, 0 );
786 /* don't reset the foreground window, if the window which is
787 getting the focus is a Wine window */
789 XGetInputFocus( event
->display
, &focus_win
, &revert
);
792 if (XFindContext( event
->display
, focus_win
, winContext
, (char **)&hwnd_tmp
) != 0)
798 /* Abey : 6-Oct-99. Check again if the focus out window is the
799 Foreground window, because in most cases the messages sent
800 above must have already changed the foreground window, in which
801 case we don't have to change the foreground window to 0 */
802 if (hwnd
== GetForegroundWindow())
804 TRACE( "lost focus, setting fg to desktop\n" );
805 SetForegroundWindow( GetDesktopWindow() );
811 /***********************************************************************
814 static void X11DRV_Expose( HWND hwnd
, XEvent
*xev
)
816 XExposeEvent
*event
= &xev
->xexpose
;
818 struct x11drv_win_data
*data
;
819 int flags
= RDW_INVALIDATE
| RDW_ERASE
| RDW_FRAME
;
821 TRACE( "win %p (%lx) %d,%d %dx%d\n",
822 hwnd
, event
->window
, event
->x
, event
->y
, event
->width
, event
->height
);
824 if (!(data
= get_win_data( hwnd
))) return;
826 rect
.left
= event
->x
;
828 rect
.right
= event
->x
+ event
->width
;
829 rect
.bottom
= event
->y
+ event
->height
;
833 data
->surface
->funcs
->lock( data
->surface
);
834 add_bounds_rect( data
->surface
->funcs
->get_bounds( data
->surface
), &rect
);
835 data
->surface
->funcs
->unlock( data
->surface
);
838 if (event
->window
!= root_window
)
840 OffsetRect( &rect
, data
->whole_rect
.left
- data
->client_rect
.left
,
841 data
->whole_rect
.top
- data
->client_rect
.top
);
843 if (GetWindowLongW( data
->hwnd
, GWL_EXSTYLE
) & WS_EX_LAYOUTRTL
)
844 mirror_rect( &data
->client_rect
, &rect
);
846 SERVER_START_REQ( update_window_zorder
)
848 req
->window
= wine_server_user_handle( hwnd
);
849 req
->rect
.left
= rect
.left
;
850 req
->rect
.top
= rect
.top
;
851 req
->rect
.right
= rect
.right
;
852 req
->rect
.bottom
= rect
.bottom
;
853 wine_server_call( req
);
857 flags
|= RDW_ALLCHILDREN
;
859 else OffsetRect( &rect
, virtual_screen_rect
.left
, virtual_screen_rect
.top
);
861 if (data
->surface
) flags
= 0;
862 release_win_data( data
);
864 if (flags
) RedrawWindow( hwnd
, &rect
, 0, flags
);
868 /**********************************************************************
871 static void X11DRV_MapNotify( HWND hwnd
, XEvent
*event
)
873 struct x11drv_win_data
*data
;
875 if (event
->xany
.window
== x11drv_thread_data()->clip_window
)
880 if (!(data
= get_win_data( hwnd
))) return;
882 if (!data
->managed
&& !data
->embedded
&& data
->mapped
)
884 HWND hwndFocus
= GetFocus();
885 if (hwndFocus
&& IsChild( hwnd
, hwndFocus
))
886 set_input_focus( thread_display(), data
->whole_window
);
888 release_win_data( data
);
892 /**********************************************************************
895 static void X11DRV_UnmapNotify( HWND hwnd
, XEvent
*event
)
897 if (event
->xany
.window
== x11drv_thread_data()->clip_window
) clipping_cursor
= 0;
901 /***********************************************************************
902 * is_net_wm_state_maximized
904 static BOOL
is_net_wm_state_maximized( Display
*display
, struct x11drv_win_data
*data
)
908 unsigned long i
, count
, remaining
;
910 if (!data
->whole_window
) return FALSE
;
912 if (!XGetWindowProperty( display
, data
->whole_window
, x11drv_atom(_NET_WM_STATE
), 0,
913 65536/sizeof(CARD32
), False
, XA_ATOM
, &type
, &format
, &count
,
914 &remaining
, (unsigned char **)&state
))
916 if (type
== XA_ATOM
&& format
== 32)
918 for (i
= 0; i
< count
; i
++)
920 if (state
[i
] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_VERT
) ||
921 state
[i
] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ
))
931 /***********************************************************************
932 * X11DRV_ReparentNotify
934 static void X11DRV_ReparentNotify( HWND hwnd
, XEvent
*xev
)
936 XReparentEvent
*event
= &xev
->xreparent
;
937 struct x11drv_win_data
*data
;
938 HWND parent
, old_parent
;
941 if (!(data
= get_win_data( hwnd
))) return;
945 release_win_data( data
);
949 if (data
->whole_window
)
951 if (event
->parent
== root_window
)
953 TRACE( "%p/%lx reparented to root\n", hwnd
, data
->whole_window
);
955 release_win_data( data
);
956 SendMessageW( hwnd
, WM_CLOSE
, 0, 0 );
959 data
->embedder
= event
->parent
;
962 TRACE( "%p/%lx reparented to %lx\n", hwnd
, data
->whole_window
, event
->parent
);
963 release_win_data( data
);
965 style
= GetWindowLongW( hwnd
, GWL_STYLE
);
966 if (event
->parent
== root_window
)
968 parent
= GetDesktopWindow();
969 style
= (style
& ~WS_CHILD
) | WS_POPUP
;
973 if (!(parent
= create_foreign_window( event
->display
, event
->parent
))) return;
974 style
= (style
& ~WS_POPUP
) | WS_CHILD
;
977 ShowWindow( hwnd
, SW_HIDE
);
978 old_parent
= SetParent( hwnd
, parent
);
979 SetWindowLongW( hwnd
, GWL_STYLE
, style
);
980 SetWindowPos( hwnd
, HWND_TOP
, event
->x
, event
->y
, 0, 0,
981 SWP_NOACTIVATE
| SWP_NOSIZE
| SWP_NOCOPYBITS
|
982 ((style
& WS_VISIBLE
) ? SWP_SHOWWINDOW
: 0) );
984 /* make old parent destroy itself if it no longer has children */
985 if (old_parent
!= GetDesktopWindow()) PostMessageW( old_parent
, WM_CLOSE
, 0, 0 );
989 /***********************************************************************
990 * X11DRV_ConfigureNotify
992 void X11DRV_ConfigureNotify( HWND hwnd
, XEvent
*xev
)
994 XConfigureEvent
*event
= &xev
->xconfigure
;
995 struct x11drv_win_data
*data
;
1000 int cx
, cy
, x
= event
->x
, y
= event
->y
;
1003 if (!(data
= get_win_data( hwnd
))) return;
1004 if (!data
->mapped
|| data
->iconic
) goto done
;
1005 if (data
->whole_window
&& !data
->managed
) goto done
;
1006 /* ignore synthetic events on foreign windows */
1007 if (event
->send_event
&& !data
->whole_window
) goto done
;
1008 if (data
->configure_serial
&& (long)(data
->configure_serial
- event
->serial
) > 0)
1010 TRACE( "win %p/%lx event %d,%d,%dx%d ignoring old serial %lu/%lu\n",
1011 hwnd
, data
->whole_window
, event
->x
, event
->y
, event
->width
, event
->height
,
1012 event
->serial
, data
->configure_serial
);
1018 parent
= GetAncestor( hwnd
, GA_PARENT
);
1019 root_coords
= event
->send_event
; /* synthetic events are always in root coords */
1021 if (!root_coords
&& parent
== GetDesktopWindow()) /* normal event, map coordinates to the root */
1024 XTranslateCoordinates( event
->display
, event
->window
, root_window
,
1025 0, 0, &x
, &y
, &child
);
1030 rect
.right
= x
+ event
->width
;
1031 rect
.bottom
= y
+ event
->height
;
1032 if (root_coords
) OffsetRect( &rect
, virtual_screen_rect
.left
, virtual_screen_rect
.top
);
1033 TRACE( "win %p/%lx new X rect %d,%d,%dx%d (event %d,%d,%dx%d)\n",
1034 hwnd
, data
->whole_window
, rect
.left
, rect
.top
, rect
.right
-rect
.left
, rect
.bottom
-rect
.top
,
1035 event
->x
, event
->y
, event
->width
, event
->height
);
1037 X11DRV_X_to_window_rect( data
, &rect
);
1038 if (root_coords
) MapWindowPoints( 0, parent
, (POINT
*)&rect
, 2 );
1040 /* Compare what has changed */
1044 cx
= rect
.right
- rect
.left
;
1045 cy
= rect
.bottom
- rect
.top
;
1046 flags
= SWP_NOACTIVATE
| SWP_NOZORDER
;
1048 if (!data
->whole_window
) flags
|= SWP_NOCOPYBITS
; /* we can't copy bits of foreign windows */
1050 if (data
->window_rect
.left
== x
&& data
->window_rect
.top
== y
) flags
|= SWP_NOMOVE
;
1052 TRACE( "%p moving from (%d,%d) to (%d,%d)\n",
1053 hwnd
, data
->window_rect
.left
, data
->window_rect
.top
, x
, y
);
1055 if ((data
->window_rect
.right
- data
->window_rect
.left
== cx
&&
1056 data
->window_rect
.bottom
- data
->window_rect
.top
== cy
) ||
1057 (IsRectEmpty( &data
->window_rect
) && event
->width
== 1 && event
->height
== 1))
1058 flags
|= SWP_NOSIZE
;
1060 TRACE( "%p resizing from (%dx%d) to (%dx%d)\n",
1061 hwnd
, data
->window_rect
.right
- data
->window_rect
.left
,
1062 data
->window_rect
.bottom
- data
->window_rect
.top
, cx
, cy
);
1064 if (is_net_wm_state_maximized( event
->display
, data
))
1066 if (!IsZoomed( data
->hwnd
))
1068 TRACE( "win %p/%lx is maximized\n", data
->hwnd
, data
->whole_window
);
1069 release_win_data( data
);
1070 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_MAXIMIZE
, 0 );
1076 if (IsZoomed( data
->hwnd
))
1078 TRACE( "window %p/%lx is no longer maximized\n", data
->hwnd
, data
->whole_window
);
1079 release_win_data( data
);
1080 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_RESTORE
, 0 );
1085 if ((flags
& (SWP_NOSIZE
| SWP_NOMOVE
)) != (SWP_NOSIZE
| SWP_NOMOVE
))
1087 release_win_data( data
);
1088 SetWindowPos( hwnd
, 0, x
, y
, cx
, cy
, flags
);
1093 release_win_data( data
);
1097 /**********************************************************************
1098 * X11DRV_GravityNotify
1100 static void X11DRV_GravityNotify( HWND hwnd
, XEvent
*xev
)
1102 XGravityEvent
*event
= &xev
->xgravity
;
1103 struct x11drv_win_data
*data
= get_win_data( hwnd
);
1104 RECT rect
, window_rect
;
1108 if (data
->whole_window
) /* only handle this for foreign windows */
1110 release_win_data( data
);
1114 rect
.left
= event
->x
;
1115 rect
.top
= event
->y
;
1116 rect
.right
= rect
.left
+ data
->whole_rect
.right
- data
->whole_rect
.left
;
1117 rect
.bottom
= rect
.top
+ data
->whole_rect
.bottom
- data
->whole_rect
.top
;
1119 TRACE( "win %p/%lx new X rect %d,%d,%dx%d (event %d,%d)\n",
1120 hwnd
, data
->whole_window
, rect
.left
, rect
.top
, rect
.right
-rect
.left
, rect
.bottom
-rect
.top
,
1121 event
->x
, event
->y
);
1123 X11DRV_X_to_window_rect( data
, &rect
);
1124 window_rect
= data
->window_rect
;
1125 release_win_data( data
);
1127 if (window_rect
.left
!= rect
.left
|| window_rect
.top
!= rect
.top
)
1128 SetWindowPos( hwnd
, 0, rect
.left
, rect
.top
, 0, 0,
1129 SWP_NOSIZE
| SWP_NOZORDER
| SWP_NOACTIVATE
| SWP_NOCOPYBITS
);
1133 /***********************************************************************
1134 * get_window_wm_state
1136 static int get_window_wm_state( Display
*display
, Window window
)
1144 int format
, ret
= -1;
1145 unsigned long count
, remaining
;
1147 if (!XGetWindowProperty( display
, window
, x11drv_atom(WM_STATE
), 0,
1148 sizeof(*state
)/sizeof(CARD32
), False
, x11drv_atom(WM_STATE
),
1149 &type
, &format
, &count
, &remaining
, (unsigned char **)&state
))
1151 if (type
== x11drv_atom(WM_STATE
) && get_property_size( format
, count
) >= sizeof(*state
))
1159 /***********************************************************************
1160 * handle_wm_state_notify
1162 * Handle a PropertyNotify for WM_STATE.
1164 static void handle_wm_state_notify( HWND hwnd
, XPropertyEvent
*event
, BOOL update_window
)
1166 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
1171 switch(event
->state
)
1173 case PropertyDelete
:
1174 TRACE( "%p/%lx: WM_STATE deleted from %d\n", data
->hwnd
, data
->whole_window
, data
->wm_state
);
1175 data
->wm_state
= WithdrawnState
;
1177 case PropertyNewValue
:
1179 int old_state
= data
->wm_state
;
1180 int new_state
= get_window_wm_state( event
->display
, data
->whole_window
);
1181 if (new_state
!= -1 && new_state
!= data
->wm_state
)
1183 TRACE( "%p/%lx: new WM_STATE %d from %d\n",
1184 data
->hwnd
, data
->whole_window
, new_state
, old_state
);
1185 data
->wm_state
= new_state
;
1186 /* ignore the initial state transition out of withdrawn state */
1187 /* metacity does Withdrawn->NormalState->IconicState when mapping an iconic window */
1188 if (!old_state
) return;
1194 if (!update_window
|| !data
->managed
|| !data
->mapped
) return;
1196 style
= GetWindowLongW( data
->hwnd
, GWL_STYLE
);
1198 if (data
->iconic
&& data
->wm_state
== NormalState
) /* restore window */
1200 data
->iconic
= FALSE
;
1201 if (is_net_wm_state_maximized( event
->display
, data
))
1203 if ((style
& WS_MAXIMIZEBOX
) && !(style
& WS_DISABLED
))
1205 TRACE( "restoring to max %p/%lx\n", data
->hwnd
, data
->whole_window
);
1206 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_MAXIMIZE
, 0 );
1208 else TRACE( "not restoring to max win %p/%lx style %08x\n",
1209 data
->hwnd
, data
->whole_window
, style
);
1211 else if (style
& (WS_MINIMIZE
| WS_MAXIMIZE
))
1213 TRACE( "restoring win %p/%lx\n", data
->hwnd
, data
->whole_window
);
1214 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_RESTORE
, 0 );
1216 else TRACE( "not restoring win %p/%lx style %08x\n", data
->hwnd
, data
->whole_window
, style
);
1218 else if (!data
->iconic
&& data
->wm_state
== IconicState
)
1220 data
->iconic
= TRUE
;
1221 if ((style
& WS_MINIMIZEBOX
) && !(style
& WS_DISABLED
))
1223 TRACE( "minimizing win %p/%lx\n", data
->hwnd
, data
->whole_window
);
1224 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_MINIMIZE
, 0 );
1226 else TRACE( "not minimizing win %p/%lx style %08x\n", data
->hwnd
, data
->whole_window
, style
);
1231 /***********************************************************************
1232 * X11DRV_PropertyNotify
1234 static void X11DRV_PropertyNotify( HWND hwnd
, XEvent
*xev
)
1236 XPropertyEvent
*event
= &xev
->xproperty
;
1239 if (event
->atom
== x11drv_atom(WM_STATE
)) handle_wm_state_notify( hwnd
, event
, TRUE
);
1243 /* event filter to wait for a WM_STATE change notification on a window */
1244 static Bool
is_wm_state_notify( Display
*display
, XEvent
*event
, XPointer arg
)
1246 if (event
->xany
.window
!= (Window
)arg
) return 0;
1247 return (event
->type
== DestroyNotify
||
1248 (event
->type
== PropertyNotify
&& event
->xproperty
.atom
== x11drv_atom(WM_STATE
)));
1251 /***********************************************************************
1252 * wait_for_withdrawn_state
1254 void wait_for_withdrawn_state( HWND hwnd
, BOOL set
)
1256 Display
*display
= thread_display();
1257 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
1258 DWORD end
= GetTickCount() + 2000;
1260 if (!data
|| !data
->managed
) return;
1262 TRACE( "waiting for window %p/%lx to become %swithdrawn\n",
1263 data
->hwnd
, data
->whole_window
, set
? "" : "not " );
1265 while (data
->whole_window
&& ((data
->wm_state
== WithdrawnState
) == !set
))
1270 while (XCheckIfEvent( display
, &event
, is_wm_state_notify
, (char *)data
->whole_window
))
1273 if (XFilterEvent( &event
, None
)) continue; /* filtered, ignore it */
1274 if (event
.type
== DestroyNotify
) call_event_handler( display
, &event
);
1275 else handle_wm_state_notify( hwnd
, &event
.xproperty
, FALSE
);
1281 int timeout
= end
- GetTickCount();
1283 pfd
.fd
= ConnectionNumber(display
);
1284 pfd
.events
= POLLIN
;
1285 if (timeout
<= 0 || poll( &pfd
, 1, timeout
) != 1)
1287 FIXME( "window %p/%lx wait timed out\n", data
->hwnd
, data
->whole_window
);
1292 TRACE( "window %p/%lx state now %d\n", data
->hwnd
, data
->whole_window
, data
->wm_state
);
1296 /*****************************************************************
1297 * SetFocus (X11DRV.@)
1301 void CDECL
X11DRV_SetFocus( HWND hwnd
)
1303 Display
*display
= thread_display();
1304 struct x11drv_win_data
*data
;
1306 if (!(hwnd
= GetAncestor( hwnd
, GA_ROOT
))) return;
1307 if (!(data
= get_win_data( hwnd
))) return;
1308 if (!data
->managed
) set_input_focus( display
, data
->whole_window
);
1309 release_win_data( data
);
1313 static HWND
find_drop_window( HWND hQueryWnd
, LPPOINT lpPt
)
1317 if (!IsWindowEnabled(hQueryWnd
)) return 0;
1319 GetWindowRect(hQueryWnd
, &tempRect
);
1321 if(!PtInRect(&tempRect
, *lpPt
)) return 0;
1323 if (!IsIconic( hQueryWnd
))
1326 ScreenToClient( hQueryWnd
, &pt
);
1327 GetClientRect( hQueryWnd
, &tempRect
);
1329 if (PtInRect( &tempRect
, pt
))
1331 HWND ret
= ChildWindowFromPointEx( hQueryWnd
, pt
, CWP_SKIPINVISIBLE
|CWP_SKIPDISABLED
);
1332 if (ret
&& ret
!= hQueryWnd
)
1334 ret
= find_drop_window( ret
, lpPt
);
1335 if (ret
) return ret
;
1340 if(!(GetWindowLongA( hQueryWnd
, GWL_EXSTYLE
) & WS_EX_ACCEPTFILES
)) return 0;
1342 ScreenToClient(hQueryWnd
, lpPt
);
1347 /**********************************************************************
1348 * EVENT_DropFromOffix
1350 * don't know if it still works (last Changelog is from 96/11/04)
1352 static void EVENT_DropFromOffiX( HWND hWnd
, XClientMessageEvent
*event
)
1354 struct x11drv_win_data
*data
;
1355 unsigned long data_length
;
1356 unsigned long aux_long
;
1357 unsigned char* p_data
= NULL
;
1359 int x
, y
, cx
, cy
, dummy
;
1361 Window win
, w_aux_root
, w_aux_child
;
1363 if (!(data
= get_win_data( hWnd
))) return;
1364 cx
= data
->whole_rect
.right
- data
->whole_rect
.left
;
1365 cy
= data
->whole_rect
.bottom
- data
->whole_rect
.top
;
1366 win
= data
->whole_window
;
1367 release_win_data( data
);
1369 XQueryPointer( event
->display
, win
, &w_aux_root
, &w_aux_child
,
1370 &x
, &y
, &dummy
, &dummy
, (unsigned int*)&aux_long
);
1371 x
+= virtual_screen_rect
.left
;
1372 y
+= virtual_screen_rect
.top
;
1374 /* find out drop point and drop window */
1375 if (x
< 0 || y
< 0 || x
> cx
|| y
> cy
)
1377 bAccept
= GetWindowLongW( hWnd
, GWL_EXSTYLE
) & WS_EX_ACCEPTFILES
;
1383 POINT pt
= { x
, y
};
1384 HWND hwndDrop
= find_drop_window( hWnd
, &pt
);
1397 if (!bAccept
) return;
1399 XGetWindowProperty( event
->display
, DefaultRootWindow(event
->display
),
1400 x11drv_atom(DndSelection
), 0, 65535, FALSE
,
1401 AnyPropertyType
, &atom_aux
, &dummy
,
1402 &data_length
, &aux_long
, &p_data
);
1404 if( !aux_long
&& p_data
) /* don't bother if > 64K */
1406 char *p
= (char *)p_data
;
1410 while( *p
) /* calculate buffer size */
1412 INT len
= GetShortPathNameA( p
, NULL
, 0 );
1413 if (len
) aux_long
+= len
+ 1;
1416 if( aux_long
&& aux_long
< 65535 )
1421 aux_long
+= sizeof(DROPFILES
) + 1;
1422 hDrop
= GlobalAlloc( GMEM_SHARE
, aux_long
);
1423 lpDrop
= GlobalLock( hDrop
);
1427 lpDrop
->pFiles
= sizeof(DROPFILES
);
1430 lpDrop
->fNC
= FALSE
;
1431 lpDrop
->fWide
= FALSE
;
1432 p_drop
= (char *)(lpDrop
+ 1);
1436 if (GetShortPathNameA( p
, p_drop
, aux_long
- (p_drop
- (char *)lpDrop
) ))
1437 p_drop
+= strlen( p_drop
) + 1;
1441 PostMessageA( hWnd
, WM_DROPFILES
, (WPARAM
)hDrop
, 0L );
1445 if( p_data
) XFree(p_data
);
1448 /**********************************************************************
1451 * drop items are separated by \n
1452 * each item is prefixed by its mime type
1454 * event->data.l[3], event->data.l[4] contains drop x,y position
1456 static void EVENT_DropURLs( HWND hWnd
, XClientMessageEvent
*event
)
1458 struct x11drv_win_data
*win_data
;
1459 unsigned long data_length
;
1460 unsigned long aux_long
, drop_len
= 0;
1461 unsigned char *p_data
= NULL
; /* property data */
1462 char *p_drop
= NULL
;
1474 if (!(GetWindowLongW( hWnd
, GWL_EXSTYLE
) & WS_EX_ACCEPTFILES
)) return;
1476 XGetWindowProperty( event
->display
, DefaultRootWindow(event
->display
),
1477 x11drv_atom(DndSelection
), 0, 65535, FALSE
,
1478 AnyPropertyType
, &u
.atom_aux
, &u
.i
,
1479 &data_length
, &aux_long
, &p_data
);
1481 WARN("property too large, truncated!\n");
1482 TRACE("urls=%s\n", p_data
);
1484 if( !aux_long
&& p_data
) { /* don't bother if > 64K */
1485 /* calculate length */
1487 next
= strchr(p
, '\n');
1490 if (strncmp(p
,"file:",5) == 0 ) {
1491 INT len
= GetShortPathNameA( p
+5, NULL
, 0 );
1492 if (len
) drop_len
+= len
+ 1;
1497 next
= strchr(p
, '\n');
1503 if( drop_len
&& drop_len
< 65535 ) {
1504 XQueryPointer( event
->display
, root_window
, &u
.w_aux
, &u
.w_aux
,
1505 &x
, &y
, &u
.i
, &u
.i
, &u
.u
);
1506 x
+= virtual_screen_rect
.left
;
1507 y
+= virtual_screen_rect
.top
;
1509 drop_len
+= sizeof(DROPFILES
) + 1;
1510 hDrop
= GlobalAlloc( GMEM_SHARE
, drop_len
);
1511 lpDrop
= GlobalLock( hDrop
);
1513 if( lpDrop
&& (win_data
= get_win_data( hWnd
)))
1515 lpDrop
->pFiles
= sizeof(DROPFILES
);
1519 ( x
< (win_data
->client_rect
.left
- win_data
->whole_rect
.left
) ||
1520 y
< (win_data
->client_rect
.top
- win_data
->whole_rect
.top
) ||
1521 x
> (win_data
->client_rect
.right
- win_data
->whole_rect
.left
) ||
1522 y
> (win_data
->client_rect
.bottom
- win_data
->whole_rect
.top
) );
1523 lpDrop
->fWide
= FALSE
;
1524 p_drop
= (char*)(lpDrop
+ 1);
1525 release_win_data( win_data
);
1528 /* create message content */
1531 next
= strchr(p
, '\n');
1534 if (strncmp(p
,"file:",5) == 0 ) {
1535 INT len
= GetShortPathNameA( p
+5, p_drop
, 65535 );
1537 TRACE("drop file %s as %s\n", p
+5, p_drop
);
1540 WARN("can't convert file %s to dos name\n", p
+5);
1543 WARN("unknown mime type %s\n", p
);
1548 next
= strchr(p
, '\n');
1555 GlobalUnlock(hDrop
);
1556 PostMessageA( hWnd
, WM_DROPFILES
, (WPARAM
)hDrop
, 0L );
1559 if( p_data
) XFree(p_data
);
1564 /**********************************************************************
1565 * handle_xembed_protocol
1567 static void handle_xembed_protocol( HWND hwnd
, XClientMessageEvent
*event
)
1569 struct x11drv_win_data
*data
= get_win_data( hwnd
);
1573 switch (event
->data
.l
[1])
1575 case XEMBED_EMBEDDED_NOTIFY
:
1576 TRACE( "win %p/%lx XEMBED_EMBEDDED_NOTIFY owner %lx\n", hwnd
, event
->window
, event
->data
.l
[3] );
1577 data
->embedder
= event
->data
.l
[3];
1580 TRACE( "win %p/%lx XEMBED message %lu(%lu)\n",
1581 hwnd
, event
->window
, event
->data
.l
[1], event
->data
.l
[2] );
1584 release_win_data( data
);
1588 /**********************************************************************
1589 * handle_dnd_protocol
1591 static void handle_dnd_protocol( HWND hwnd
, XClientMessageEvent
*event
)
1594 int root_x
, root_y
, child_x
, child_y
;
1597 /* query window (drag&drop event contains only drag window) */
1598 XQueryPointer( event
->display
, root_window
, &root
, &child
,
1599 &root_x
, &root_y
, &child_x
, &child_y
, &u
);
1600 if (XFindContext( event
->display
, child
, winContext
, (char **)&hwnd
) != 0) hwnd
= 0;
1602 if (event
->data
.l
[0] == DndFile
|| event
->data
.l
[0] == DndFiles
)
1603 EVENT_DropFromOffiX(hwnd
, event
);
1604 else if (event
->data
.l
[0] == DndURL
)
1605 EVENT_DropURLs(hwnd
, event
);
1609 struct client_message_handler
1611 int atom
; /* protocol atom */
1612 void (*handler
)(HWND
, XClientMessageEvent
*); /* corresponding handler function */
1615 static const struct client_message_handler client_messages
[] =
1617 { XATOM_MANAGER
, handle_manager_message
},
1618 { XATOM_WM_PROTOCOLS
, handle_wm_protocols
},
1619 { XATOM__XEMBED
, handle_xembed_protocol
},
1620 { XATOM_DndProtocol
, handle_dnd_protocol
},
1621 { XATOM_XdndEnter
, X11DRV_XDND_EnterEvent
},
1622 { XATOM_XdndPosition
, X11DRV_XDND_PositionEvent
},
1623 { XATOM_XdndDrop
, X11DRV_XDND_DropEvent
},
1624 { XATOM_XdndLeave
, X11DRV_XDND_LeaveEvent
}
1628 /**********************************************************************
1629 * X11DRV_ClientMessage
1631 static void X11DRV_ClientMessage( HWND hwnd
, XEvent
*xev
)
1633 XClientMessageEvent
*event
= &xev
->xclient
;
1638 if (event
->format
!= 32)
1640 WARN( "Don't know how to handle format %d\n", event
->format
);
1644 for (i
= 0; i
< sizeof(client_messages
)/sizeof(client_messages
[0]); i
++)
1646 if (event
->message_type
== X11DRV_Atoms
[client_messages
[i
].atom
- FIRST_XATOM
])
1648 client_messages
[i
].handler( hwnd
, event
);
1652 TRACE( "no handler found for %ld\n", event
->message_type
);