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>
40 #define NONAMELESSUNION
41 #define NONAMELESSSTRUCT
49 /* avoid conflict with field names in included win32 headers */
51 #include "shlobj.h" /* DROPFILES */
54 #include "wine/server.h"
55 #include "wine/debug.h"
57 WINE_DEFAULT_DEBUG_CHANNEL(event
);
59 extern BOOL ximInComposeMode
;
61 #define DndNotDnd -1 /* OffiX drag&drop */
73 #define DndURL 128 /* KDE drag&drop */
76 static void X11DRV_FocusIn( HWND hwnd
, XEvent
*event
);
77 static void X11DRV_FocusOut( HWND hwnd
, XEvent
*event
);
78 static void X11DRV_Expose( HWND hwnd
, XEvent
*event
);
79 static void X11DRV_MapNotify( HWND hwnd
, XEvent
*event
);
80 static void X11DRV_ConfigureNotify( HWND hwnd
, XEvent
*event
);
81 static void X11DRV_PropertyNotify( HWND hwnd
, XEvent
*event
);
82 static void X11DRV_ClientMessage( HWND hwnd
, XEvent
*event
);
86 int type
; /* event type */
87 x11drv_event_handler handler
; /* corresponding handler function */
90 #define MAX_EVENT_HANDLERS 64
92 static struct event_handler handlers
[MAX_EVENT_HANDLERS
] =
94 /* list must be sorted by event type */
95 { KeyPress
, X11DRV_KeyEvent
},
96 { KeyRelease
, X11DRV_KeyEvent
},
97 { ButtonPress
, X11DRV_ButtonPress
},
98 { ButtonRelease
, X11DRV_ButtonRelease
},
99 { MotionNotify
, X11DRV_MotionNotify
},
100 { EnterNotify
, X11DRV_EnterNotify
},
102 { FocusIn
, X11DRV_FocusIn
},
103 { FocusOut
, X11DRV_FocusOut
},
104 { KeymapNotify
, X11DRV_KeymapNotify
},
105 { Expose
, X11DRV_Expose
},
108 /* VisibilityNotify */
110 { DestroyNotify
, X11DRV_DestroyNotify
},
112 { MapNotify
, X11DRV_MapNotify
},
115 { ConfigureNotify
, X11DRV_ConfigureNotify
},
116 /* ConfigureRequest */
119 /* CirculateNotify */
120 /* CirculateRequest */
121 { PropertyNotify
, X11DRV_PropertyNotify
},
122 { SelectionClear
, X11DRV_SelectionClear
},
123 { SelectionRequest
, X11DRV_SelectionRequest
},
124 /* SelectionNotify */
126 { ClientMessage
, X11DRV_ClientMessage
},
127 { MappingNotify
, X11DRV_MappingNotify
},
130 static int nb_event_handlers
= 18; /* change this if you add handlers above */
133 /* return the name of an X event */
134 static const char *dbgstr_event( int type
)
136 static const char * const event_names
[] =
138 "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease",
139 "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut",
140 "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify",
141 "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",
142 "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify",
143 "ResizeRequest", "CirculateNotify", "CirculateRequest", "PropertyNotify",
144 "SelectionClear", "SelectionRequest", "SelectionNotify", "ColormapNotify",
145 "ClientMessage", "MappingNotify"
148 if (type
>= KeyPress
&& type
<= MappingNotify
) return event_names
[type
- KeyPress
];
149 return wine_dbg_sprintf( "Extension event %d", type
);
153 /***********************************************************************
156 * Find the handler for a given event type. Caller must hold the x11 lock.
158 static inline x11drv_event_handler
find_handler( int type
)
160 int min
= 0, max
= nb_event_handlers
- 1;
164 int pos
= (min
+ max
) / 2;
165 if (handlers
[pos
].type
== type
) return handlers
[pos
].handler
;
166 if (handlers
[pos
].type
> type
) max
= pos
- 1;
173 /***********************************************************************
174 * X11DRV_register_event_handler
176 * Register a handler for a given event type.
177 * If already registered, overwrite the previous handler.
179 void X11DRV_register_event_handler( int type
, x11drv_event_handler handler
)
185 max
= nb_event_handlers
- 1;
188 int pos
= (min
+ max
) / 2;
189 if (handlers
[pos
].type
== type
)
191 handlers
[pos
].handler
= handler
;
194 if (handlers
[pos
].type
> type
) max
= pos
- 1;
197 /* insert it between max and min */
198 memmove( &handlers
[min
+1], &handlers
[min
], (nb_event_handlers
- min
) * sizeof(handlers
[0]) );
199 handlers
[min
].type
= type
;
200 handlers
[min
].handler
= handler
;
202 assert( nb_event_handlers
<= MAX_EVENT_HANDLERS
);
205 TRACE("registered handler %p for event %d count %d\n", handler
, type
, nb_event_handlers
);
209 /***********************************************************************
212 static Bool
filter_event( Display
*display
, XEvent
*event
, char *arg
)
214 ULONG_PTR mask
= (ULONG_PTR
)arg
;
216 if ((mask
& QS_ALLINPUT
) == QS_ALLINPUT
) return 1;
224 return (mask
& QS_KEY
) != 0;
227 return (mask
& QS_MOUSEBUTTON
) != 0;
231 return (mask
& QS_MOUSEMOVE
) != 0;
233 return (mask
& QS_PAINT
) != 0;
238 case ConfigureNotify
:
241 return (mask
& QS_POSTMESSAGE
) != 0;
243 return (mask
& QS_SENDMESSAGE
) != 0;
248 enum event_merge_action
250 MERGE_DISCARD
, /* discard the old event */
251 MERGE_HANDLE
, /* handle the old event */
252 MERGE_KEEP
/* keep the old event for future merging */
255 /***********************************************************************
258 * Try to merge 2 consecutive events.
260 static enum event_merge_action
merge_events( XEvent
*prev
, XEvent
*next
)
264 case ConfigureNotify
:
267 case ConfigureNotify
:
268 if (prev
->xany
.window
== next
->xany
.window
)
270 TRACE( "discarding duplicate ConfigureNotify for window %lx\n", prev
->xany
.window
);
271 return MERGE_DISCARD
;
280 if (prev
->xany
.window
== next
->xany
.window
&& next
->type
== MotionNotify
)
282 TRACE( "discarding duplicate MotionNotify for window %lx\n", prev
->xany
.window
);
283 return MERGE_DISCARD
;
291 /***********************************************************************
294 static inline void call_event_handler( Display
*display
, XEvent
*event
)
297 x11drv_event_handler handler
;
299 struct x11drv_thread_data
*thread_data
;
301 if (!(handler
= find_handler( event
->type
)))
303 TRACE( "%s for win %lx, ignoring\n", dbgstr_event( event
->type
), event
->xany
.window
);
304 return; /* no handler, ignore it */
307 if (XFindContext( display
, event
->xany
.window
, winContext
, (char **)&hwnd
) != 0)
308 hwnd
= 0; /* not for a registered window */
309 if (!hwnd
&& event
->xany
.window
== root_window
) hwnd
= GetDesktopWindow();
311 TRACE( "%s for hwnd/window %p/%lx\n",
312 dbgstr_event( event
->type
), hwnd
, event
->xany
.window
);
314 thread_data
= x11drv_thread_data();
315 prev
= thread_data
->current_event
;
316 thread_data
->current_event
= event
;
317 handler( hwnd
, event
);
318 thread_data
->current_event
= prev
;
323 /***********************************************************************
326 static int process_events( Display
*display
, Bool (*filter
)(), ULONG_PTR arg
)
328 XEvent event
, prev_event
;
330 enum event_merge_action action
= MERGE_DISCARD
;
334 while (XCheckIfEvent( display
, &event
, filter
, (char *)arg
))
337 if (XFilterEvent( &event
, None
))
340 * SCIM on linux filters key events strangely. It does not filter the
341 * KeyPress events for these keys however it does filter the
342 * KeyRelease events. This causes wine to become very confused as
343 * to the keyboard state.
345 * We need to let those KeyRelease events be processed so that the
346 * keyboard state is correct.
348 if (event
.type
== KeyRelease
)
351 XKeyEvent
*keyevent
= &event
.xkey
;
353 XLookupString(keyevent
, NULL
, 0, &keysym
, NULL
);
354 if (!(keysym
== XK_Shift_L
||
355 keysym
== XK_Shift_R
||
356 keysym
== XK_Control_L
||
357 keysym
== XK_Control_R
||
358 keysym
== XK_Alt_R
||
359 keysym
== XK_Alt_L
||
360 keysym
== XK_Meta_R
||
361 keysym
== XK_Meta_L
))
362 continue; /* not a key we care about, ignore it */
365 continue; /* filtered, ignore it */
367 if (prev_event
.type
) action
= merge_events( &prev_event
, &event
);
370 case MERGE_DISCARD
: /* discard prev, keep new */
373 case MERGE_HANDLE
: /* handle prev, keep new */
374 call_event_handler( display
, &prev_event
);
377 case MERGE_KEEP
: /* handle new, keep prev for future merging */
378 call_event_handler( display
, &event
);
382 XFlush( gdi_display
);
383 if (prev_event
.type
) call_event_handler( display
, &prev_event
);
385 if (count
) TRACE( "processed %d events\n", count
);
390 /***********************************************************************
391 * MsgWaitForMultipleObjectsEx (X11DRV.@)
393 DWORD
X11DRV_MsgWaitForMultipleObjectsEx( DWORD count
, const HANDLE
*handles
,
394 DWORD timeout
, DWORD mask
, DWORD flags
)
397 struct x11drv_thread_data
*data
= TlsGetValue( thread_data_tls_index
);
401 if (!count
&& !timeout
) return WAIT_TIMEOUT
;
402 return WaitForMultipleObjectsEx( count
, handles
, flags
& MWMO_WAITALL
,
403 timeout
, flags
& MWMO_ALERTABLE
);
406 if (data
->current_event
) mask
= 0; /* don't process nested events */
408 if (process_events( data
->display
, filter_event
, mask
)) ret
= count
- 1;
409 else if (count
|| timeout
)
411 ret
= WaitForMultipleObjectsEx( count
, handles
, flags
& MWMO_WAITALL
,
412 timeout
, flags
& MWMO_ALERTABLE
);
413 if (ret
== count
- 1) process_events( data
->display
, filter_event
, mask
);
415 else ret
= WAIT_TIMEOUT
;
420 /***********************************************************************
421 * EVENT_x11_time_to_win32_time
423 * Make our timer and the X timer line up as best we can
424 * Pass 0 to retrieve the current adjustment value (times -1)
426 DWORD
EVENT_x11_time_to_win32_time(Time time
)
428 static DWORD adjust
= 0;
429 DWORD now
= GetTickCount();
432 if (! adjust
&& time
!= 0)
439 /* If we got an event in the 'future', then our clock is clearly wrong.
440 If we got it more than 10000 ms in the future, then it's most likely
441 that the clock has wrapped. */
444 if (ret
> now
&& ((ret
- now
) < 10000) && time
!= 0)
455 /*******************************************************************
456 * can_activate_window
458 * Check if we can activate the specified window.
460 static inline BOOL
can_activate_window( HWND hwnd
)
462 LONG style
= GetWindowLongW( hwnd
, GWL_STYLE
);
463 if (!(style
& WS_VISIBLE
)) return FALSE
;
464 if ((style
& (WS_POPUP
|WS_CHILD
)) == WS_CHILD
) return FALSE
;
465 if (hwnd
== GetDesktopWindow()) return FALSE
;
466 return !(style
& WS_DISABLED
);
470 /**********************************************************************
473 static void set_focus( Display
*display
, HWND hwnd
, Time time
)
478 TRACE( "setting foreground window to %p\n", hwnd
);
479 SetForegroundWindow( hwnd
);
482 if (focus
) focus
= GetAncestor( focus
, GA_ROOT
);
483 win
= X11DRV_get_whole_window(focus
);
487 TRACE( "setting focus to %p (%lx) time=%ld\n", focus
, win
, time
);
489 XSetInputFocus( display
, win
, RevertToParent
, time
);
495 /**********************************************************************
496 * handle_wm_protocols
498 static void handle_wm_protocols( HWND hwnd
, XClientMessageEvent
*event
)
500 Atom protocol
= (Atom
)event
->data
.l
[0];
502 if (!protocol
) return;
504 if (protocol
== x11drv_atom(WM_DELETE_WINDOW
))
506 /* Ignore the delete window request if the window has been disabled
507 * and we are in managed mode. This is to disallow applications from
508 * being closed by the window manager while in a modal state.
510 if (IsWindowEnabled(hwnd
))
514 if (GetClassLongW(hwnd
, GCL_STYLE
) & CS_NOCLOSE
) return;
515 hSysMenu
= GetSystemMenu(hwnd
, FALSE
);
518 UINT state
= GetMenuState(hSysMenu
, SC_CLOSE
, MF_BYCOMMAND
);
519 if (state
== 0xFFFFFFFF || (state
& (MF_DISABLED
| MF_GRAYED
)))
522 if (GetActiveWindow() != hwnd
)
524 LRESULT ma
= SendMessageW( hwnd
, WM_MOUSEACTIVATE
,
525 (WPARAM
)GetAncestor( hwnd
, GA_ROOT
),
526 MAKELONG(HTCLOSE
,WM_LBUTTONDOWN
) );
529 case MA_NOACTIVATEANDEAT
:
530 case MA_ACTIVATEANDEAT
:
536 SetActiveWindow(hwnd
);
539 WARN( "unknown WM_MOUSEACTIVATE code %d\n", (int) ma
);
543 PostMessageW( hwnd
, WM_X11DRV_DELETE_WINDOW
, 0, 0 );
546 else if (protocol
== x11drv_atom(WM_TAKE_FOCUS
))
548 Time event_time
= (Time
)event
->data
.l
[1];
549 HWND last_focus
= x11drv_thread_data()->last_focus
;
551 TRACE( "got take focus msg for %p, enabled=%d, visible=%d (style %08x), focus=%p, active=%p, fg=%p, last=%p\n",
552 hwnd
, IsWindowEnabled(hwnd
), IsWindowVisible(hwnd
), GetWindowLongW(hwnd
, GWL_STYLE
),
553 GetFocus(), GetActiveWindow(), GetForegroundWindow(), last_focus
);
555 if (hwnd
== GetForegroundWindow()) return;
557 if (can_activate_window(hwnd
))
559 /* simulate a mouse click on the caption to find out
560 * whether the window wants to be activated */
561 LRESULT ma
= SendMessageW( hwnd
, WM_MOUSEACTIVATE
,
562 (WPARAM
)GetAncestor( hwnd
, GA_ROOT
),
563 MAKELONG(HTCAPTION
,WM_LBUTTONDOWN
) );
564 if (ma
!= MA_NOACTIVATEANDEAT
&& ma
!= MA_NOACTIVATE
)
566 set_focus( event
->display
, hwnd
, event_time
);
570 /* try to find some other window to give the focus to */
572 if (hwnd
) hwnd
= GetAncestor( hwnd
, GA_ROOT
);
573 if (!hwnd
) hwnd
= GetActiveWindow();
574 if (!hwnd
) hwnd
= last_focus
;
575 if (hwnd
&& can_activate_window(hwnd
)) set_focus( event
->display
, hwnd
, event_time
);
577 else if (protocol
== x11drv_atom(_NET_WM_PING
))
579 XClientMessageEvent xev
;
582 TRACE("NET_WM Ping\n");
584 xev
.window
= DefaultRootWindow(xev
.display
);
585 XSendEvent(xev
.display
, xev
.window
, False
, SubstructureRedirectMask
| SubstructureNotifyMask
, (XEvent
*)&xev
);
587 /* this line is semi-stolen from gtk2 */
588 TRACE("NET_WM Pong\n");
593 static const char * const focus_details
[] =
599 "NotifyNonlinearVirtual",
605 /**********************************************************************
608 static void X11DRV_FocusIn( HWND hwnd
, XEvent
*xev
)
610 XFocusChangeEvent
*event
= &xev
->xfocus
;
615 TRACE( "win %p xwin %lx detail=%s\n", hwnd
, event
->window
, focus_details
[event
->detail
] );
617 if (event
->detail
== NotifyPointer
) return;
619 if ((xic
= X11DRV_get_ic( hwnd
)))
625 if (use_take_focus
) return; /* ignore FocusIn if we are using take focus */
627 if (!can_activate_window(hwnd
))
629 HWND hwnd
= GetFocus();
630 if (hwnd
) hwnd
= GetAncestor( hwnd
, GA_ROOT
);
631 if (!hwnd
) hwnd
= GetActiveWindow();
632 if (!hwnd
) hwnd
= x11drv_thread_data()->last_focus
;
633 if (hwnd
&& can_activate_window(hwnd
)) set_focus( event
->display
, hwnd
, CurrentTime
);
635 else SetForegroundWindow( hwnd
);
639 /**********************************************************************
642 * Note: only top-level windows get FocusOut events.
644 static void X11DRV_FocusOut( HWND hwnd
, XEvent
*xev
)
646 XFocusChangeEvent
*event
= &xev
->xfocus
;
654 TRACE( "win %p xwin %lx detail=%s\n", hwnd
, event
->window
, focus_details
[event
->detail
] );
656 if (event
->detail
== NotifyPointer
) return;
657 if (ximInComposeMode
) return;
659 x11drv_thread_data()->last_focus
= hwnd
;
660 if ((xic
= X11DRV_get_ic( hwnd
)))
663 XUnsetICFocus( xic
);
666 if (hwnd
!= GetForegroundWindow()) return;
667 SendMessageW( hwnd
, WM_CANCELMODE
, 0, 0 );
669 /* don't reset the foreground window, if the window which is
670 getting the focus is a Wine window */
673 XGetInputFocus( event
->display
, &focus_win
, &revert
);
676 if (XFindContext( event
->display
, focus_win
, winContext
, (char **)&hwnd_tmp
) != 0)
683 /* Abey : 6-Oct-99. Check again if the focus out window is the
684 Foreground window, because in most cases the messages sent
685 above must have already changed the foreground window, in which
686 case we don't have to change the foreground window to 0 */
687 if (hwnd
== GetForegroundWindow())
689 TRACE( "lost focus, setting fg to desktop\n" );
690 SetForegroundWindow( GetDesktopWindow() );
696 /***********************************************************************
699 static void X11DRV_Expose( HWND hwnd
, XEvent
*xev
)
701 XExposeEvent
*event
= &xev
->xexpose
;
703 struct x11drv_win_data
*data
;
704 int flags
= RDW_INVALIDATE
| RDW_ERASE
;
706 TRACE( "win %p (%lx) %d,%d %dx%d\n",
707 hwnd
, event
->window
, event
->x
, event
->y
, event
->width
, event
->height
);
709 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
711 if (event
->window
== data
->whole_window
)
713 rect
.left
= data
->whole_rect
.left
+ event
->x
;
714 rect
.top
= data
->whole_rect
.top
+ event
->y
;
719 rect
.left
= data
->client_rect
.left
+ event
->x
;
720 rect
.top
= data
->client_rect
.top
+ event
->y
;
722 rect
.right
= rect
.left
+ event
->width
;
723 rect
.bottom
= rect
.top
+ event
->height
;
725 if (event
->window
!= root_window
)
727 SERVER_START_REQ( update_window_zorder
)
730 req
->rect
.left
= rect
.left
;
731 req
->rect
.top
= rect
.top
;
732 req
->rect
.right
= rect
.right
;
733 req
->rect
.bottom
= rect
.bottom
;
734 wine_server_call( req
);
738 /* make position relative to client area instead of parent */
739 OffsetRect( &rect
, -data
->client_rect
.left
, -data
->client_rect
.top
);
740 flags
|= RDW_ALLCHILDREN
;
743 RedrawWindow( hwnd
, &rect
, 0, flags
);
747 /**********************************************************************
750 static void X11DRV_MapNotify( HWND hwnd
, XEvent
*event
)
752 struct x11drv_win_data
*data
;
754 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
755 if (!data
->mapped
) return;
759 HWND hwndFocus
= GetFocus();
760 if (hwndFocus
&& IsChild( hwnd
, hwndFocus
)) X11DRV_SetFocus(hwndFocus
); /* FIXME */
765 /***********************************************************************
766 * is_net_wm_state_maximized
768 static BOOL
is_net_wm_state_maximized( Display
*display
, struct x11drv_win_data
*data
)
772 unsigned long i
, count
, remaining
;
775 if (!XGetWindowProperty( display
, data
->whole_window
, x11drv_atom(_NET_WM_STATE
), 0,
776 65536/sizeof(CARD32
), False
, XA_ATOM
, &type
, &format
, &count
,
777 &remaining
, (unsigned char **)&state
))
779 if (type
== XA_ATOM
&& format
== 32)
781 for (i
= 0; i
< count
; i
++)
783 if (state
[i
] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_VERT
) ||
784 state
[i
] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ
))
795 /***********************************************************************
796 * X11DRV_ConfigureNotify
798 void X11DRV_ConfigureNotify( HWND hwnd
, XEvent
*xev
)
800 XConfigureEvent
*event
= &xev
->xconfigure
;
801 struct x11drv_win_data
*data
;
804 int cx
, cy
, x
= event
->x
, y
= event
->y
;
807 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
808 if (!data
->mapped
|| data
->iconic
) return;
812 if (!event
->send_event
) /* normal event, need to map coordinates to the root */
816 XTranslateCoordinates( event
->display
, data
->whole_window
, root_window
,
817 0, 0, &x
, &y
, &child
);
822 rect
.right
= x
+ event
->width
;
823 rect
.bottom
= y
+ event
->height
;
824 OffsetRect( &rect
, virtual_screen_rect
.left
, virtual_screen_rect
.top
);
825 TRACE( "win %p/%lx new X rect %d,%d,%dx%d (event %d,%d,%dx%d)\n",
826 hwnd
, data
->whole_window
, rect
.left
, rect
.top
, rect
.right
-rect
.left
, rect
.bottom
-rect
.top
,
827 event
->x
, event
->y
, event
->width
, event
->height
);
828 X11DRV_X_to_window_rect( data
, &rect
);
832 cx
= rect
.right
- rect
.left
;
833 cy
= rect
.bottom
- rect
.top
;
834 flags
= SWP_NOACTIVATE
| SWP_NOZORDER
;
836 if (is_net_wm_state_maximized( event
->display
, data
))
838 if (!IsZoomed( data
->hwnd
))
840 TRACE( "win %p/%lx is maximized\n", data
->hwnd
, data
->whole_window
);
841 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_MAXIMIZE
, 0 );
847 if (IsZoomed( data
->hwnd
))
849 TRACE( "window %p/%lx is no longer maximized\n", data
->hwnd
, data
->whole_window
);
850 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_RESTORE
, 0 );
855 /* Compare what has changed */
857 GetWindowRect( hwnd
, &rect
);
858 if (rect
.left
== x
&& rect
.top
== y
) flags
|= SWP_NOMOVE
;
860 TRACE( "%p moving from (%d,%d) to (%d,%d)\n",
861 hwnd
, rect
.left
, rect
.top
, x
, y
);
863 if ((rect
.right
- rect
.left
== cx
&& rect
.bottom
- rect
.top
== cy
) ||
864 (IsRectEmpty( &rect
) && event
->width
== 1 && event
->height
== 1))
866 if (flags
& SWP_NOMOVE
) return; /* if nothing changed, don't do anything */
870 TRACE( "%p resizing from (%dx%d) to (%dx%d)\n",
871 hwnd
, rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, cx
, cy
);
873 SetWindowPos( hwnd
, 0, x
, y
, cx
, cy
, flags
);
877 /***********************************************************************
878 * get_window_wm_state
880 static int get_window_wm_state( Display
*display
, struct x11drv_win_data
*data
)
888 int format
, ret
= -1;
889 unsigned long count
, remaining
;
892 if (!XGetWindowProperty( display
, data
->whole_window
, x11drv_atom(WM_STATE
), 0,
893 sizeof(*state
)/sizeof(CARD32
), False
, x11drv_atom(WM_STATE
),
894 &type
, &format
, &count
, &remaining
, (unsigned char **)&state
))
896 if (type
== x11drv_atom(WM_STATE
) && get_property_size( format
, count
) >= sizeof(*state
))
905 /***********************************************************************
906 * handle_wm_state_notify
908 * Handle a PropertyNotify for WM_STATE.
910 static void handle_wm_state_notify( struct x11drv_win_data
*data
, XPropertyEvent
*event
,
916 data
->wm_state
= WithdrawnState
;
917 TRACE( "%p/%lx: WM_STATE deleted\n", data
->hwnd
, data
->whole_window
);
919 case PropertyNewValue
:
921 int new_state
= get_window_wm_state( event
->display
, data
);
922 if (new_state
!= -1 && new_state
!= data
->wm_state
)
924 TRACE( "%p/%lx: new WM_STATE %d\n", data
->hwnd
, data
->whole_window
, new_state
);
925 data
->wm_state
= new_state
;
931 if (!update_window
|| !data
->managed
|| !data
->mapped
) return;
933 if (data
->iconic
&& data
->wm_state
== NormalState
) /* restore window */
935 data
->iconic
= FALSE
;
936 if (is_net_wm_state_maximized( event
->display
, data
))
938 TRACE( "restoring to max %p/%lx\n", data
->hwnd
, data
->whole_window
);
939 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_MAXIMIZE
, 0 );
943 TRACE( "restoring win %p/%lx\n", data
->hwnd
, data
->whole_window
);
944 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_RESTORE
, 0 );
947 else if (!data
->iconic
&& data
->wm_state
== IconicState
)
949 TRACE( "minimizing win %p/%lx\n", data
->hwnd
, data
->whole_window
);
951 SendMessageW( data
->hwnd
, WM_SYSCOMMAND
, SC_MINIMIZE
, 0 );
956 /***********************************************************************
957 * X11DRV_PropertyNotify
959 static void X11DRV_PropertyNotify( HWND hwnd
, XEvent
*xev
)
961 XPropertyEvent
*event
= &xev
->xproperty
;
962 struct x11drv_win_data
*data
;
965 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
967 if (event
->atom
== x11drv_atom(WM_STATE
)) handle_wm_state_notify( data
, event
, TRUE
);
971 /* event filter to wait for a WM_STATE change notification on a window */
972 static Bool
is_wm_state_notify( Display
*display
, XEvent
*event
, XPointer arg
)
974 if (event
->xany
.window
!= (Window
)arg
) return 0;
975 return (event
->type
== DestroyNotify
||
976 (event
->type
== PropertyNotify
&& event
->xproperty
.atom
== x11drv_atom(WM_STATE
)));
979 /***********************************************************************
980 * wait_for_withdrawn_state
982 void wait_for_withdrawn_state( Display
*display
, struct x11drv_win_data
*data
, BOOL set
)
984 DWORD end
= GetTickCount() + 2000;
986 if (!data
->managed
) return;
988 TRACE( "waiting for window %p/%lx to become %swithdrawn\n",
989 data
->hwnd
, data
->whole_window
, set
? "" : "not " );
991 while (data
->whole_window
&& ((data
->wm_state
== WithdrawnState
) == !set
))
997 while (XCheckIfEvent( display
, &event
, is_wm_state_notify
, (char *)data
->whole_window
))
1000 if (XFilterEvent( &event
, None
)) continue; /* filtered, ignore it */
1001 if (event
.type
== DestroyNotify
) call_event_handler( display
, &event
);
1004 wine_tsx11_unlock();
1005 handle_wm_state_notify( data
, &event
.xproperty
, FALSE
);
1009 wine_tsx11_unlock();
1014 int timeout
= end
- GetTickCount();
1016 pfd
.fd
= ConnectionNumber(display
);
1017 pfd
.events
= POLLIN
;
1018 if (timeout
<= 0 || poll( &pfd
, 1, timeout
) != 1)
1020 FIXME( "window %p/%lx wait timed out\n", data
->hwnd
, data
->whole_window
);
1025 TRACE( "window %p/%lx state now %d\n", data
->hwnd
, data
->whole_window
, data
->wm_state
);
1029 static HWND
find_drop_window( HWND hQueryWnd
, LPPOINT lpPt
)
1033 if (!IsWindowEnabled(hQueryWnd
)) return 0;
1035 GetWindowRect(hQueryWnd
, &tempRect
);
1037 if(!PtInRect(&tempRect
, *lpPt
)) return 0;
1039 if (!IsIconic( hQueryWnd
))
1042 ScreenToClient( hQueryWnd
, &pt
);
1043 GetClientRect( hQueryWnd
, &tempRect
);
1045 if (PtInRect( &tempRect
, pt
))
1047 HWND ret
= ChildWindowFromPointEx( hQueryWnd
, pt
, CWP_SKIPINVISIBLE
|CWP_SKIPDISABLED
);
1048 if (ret
&& ret
!= hQueryWnd
)
1050 ret
= find_drop_window( ret
, lpPt
);
1051 if (ret
) return ret
;
1056 if(!(GetWindowLongA( hQueryWnd
, GWL_EXSTYLE
) & WS_EX_ACCEPTFILES
)) return 0;
1058 ScreenToClient(hQueryWnd
, lpPt
);
1063 /**********************************************************************
1064 * EVENT_DropFromOffix
1066 * don't know if it still works (last Changelog is from 96/11/04)
1068 static void EVENT_DropFromOffiX( HWND hWnd
, XClientMessageEvent
*event
)
1070 struct x11drv_win_data
*data
;
1071 unsigned long data_length
;
1072 unsigned long aux_long
;
1073 unsigned char* p_data
= NULL
;
1077 Window win
, w_aux_root
, w_aux_child
;
1079 win
= X11DRV_get_whole_window(hWnd
);
1081 XQueryPointer( event
->display
, win
, &w_aux_root
, &w_aux_child
,
1082 &x
, &y
, &dummy
, &dummy
, (unsigned int*)&aux_long
);
1083 x
+= virtual_screen_rect
.left
;
1084 y
+= virtual_screen_rect
.top
;
1085 wine_tsx11_unlock();
1087 if (!(data
= X11DRV_get_win_data( hWnd
))) return;
1089 /* find out drop point and drop window */
1090 if( x
< 0 || y
< 0 ||
1091 x
> (data
->whole_rect
.right
- data
->whole_rect
.left
) ||
1092 y
> (data
->whole_rect
.bottom
- data
->whole_rect
.top
) )
1094 bAccept
= GetWindowLongW( hWnd
, GWL_EXSTYLE
) & WS_EX_ACCEPTFILES
;
1100 POINT pt
= { x
, y
};
1101 HWND hwndDrop
= find_drop_window( hWnd
, &pt
);
1114 if (!bAccept
) return;
1117 XGetWindowProperty( event
->display
, DefaultRootWindow(event
->display
),
1118 x11drv_atom(DndSelection
), 0, 65535, FALSE
,
1119 AnyPropertyType
, &atom_aux
, &dummy
,
1120 &data_length
, &aux_long
, &p_data
);
1121 wine_tsx11_unlock();
1123 if( !aux_long
&& p_data
) /* don't bother if > 64K */
1125 char *p
= (char *)p_data
;
1129 while( *p
) /* calculate buffer size */
1131 INT len
= GetShortPathNameA( p
, NULL
, 0 );
1132 if (len
) aux_long
+= len
+ 1;
1135 if( aux_long
&& aux_long
< 65535 )
1140 aux_long
+= sizeof(DROPFILES
) + 1;
1141 hDrop
= GlobalAlloc( GMEM_SHARE
, aux_long
);
1142 lpDrop
= (DROPFILES
*)GlobalLock( hDrop
);
1146 lpDrop
->pFiles
= sizeof(DROPFILES
);
1149 lpDrop
->fNC
= FALSE
;
1150 lpDrop
->fWide
= FALSE
;
1151 p_drop
= (char *)(lpDrop
+ 1);
1155 if (GetShortPathNameA( p
, p_drop
, aux_long
- (p_drop
- (char *)lpDrop
) ))
1156 p_drop
+= strlen( p_drop
) + 1;
1160 PostMessageA( hWnd
, WM_DROPFILES
, (WPARAM
)hDrop
, 0L );
1165 if( p_data
) XFree(p_data
);
1166 wine_tsx11_unlock();
1169 /**********************************************************************
1172 * drop items are separated by \n
1173 * each item is prefixed by its mime type
1175 * event->data.l[3], event->data.l[4] contains drop x,y position
1177 static void EVENT_DropURLs( HWND hWnd
, XClientMessageEvent
*event
)
1179 struct x11drv_win_data
*win_data
;
1180 unsigned long data_length
;
1181 unsigned long aux_long
, drop_len
= 0;
1182 unsigned char *p_data
= NULL
; /* property data */
1183 char *p_drop
= NULL
;
1195 if (!(GetWindowLongW( hWnd
, GWL_EXSTYLE
) & WS_EX_ACCEPTFILES
)) return;
1198 XGetWindowProperty( event
->display
, DefaultRootWindow(event
->display
),
1199 x11drv_atom(DndSelection
), 0, 65535, FALSE
,
1200 AnyPropertyType
, &u
.atom_aux
, &u
.i
,
1201 &data_length
, &aux_long
, &p_data
);
1202 wine_tsx11_unlock();
1204 WARN("property too large, truncated!\n");
1205 TRACE("urls=%s\n", p_data
);
1207 if( !aux_long
&& p_data
) { /* don't bother if > 64K */
1208 /* calculate length */
1210 next
= strchr(p
, '\n');
1213 if (strncmp(p
,"file:",5) == 0 ) {
1214 INT len
= GetShortPathNameA( p
+5, NULL
, 0 );
1215 if (len
) drop_len
+= len
+ 1;
1220 next
= strchr(p
, '\n');
1226 if( drop_len
&& drop_len
< 65535 ) {
1228 XQueryPointer( event
->display
, root_window
, &u
.w_aux
, &u
.w_aux
,
1229 &x
, &y
, &u
.i
, &u
.i
, &u
.u
);
1230 x
+= virtual_screen_rect
.left
;
1231 y
+= virtual_screen_rect
.top
;
1232 wine_tsx11_unlock();
1234 drop_len
+= sizeof(DROPFILES
) + 1;
1235 hDrop
= GlobalAlloc( GMEM_SHARE
, drop_len
);
1236 lpDrop
= (DROPFILES
*) GlobalLock( hDrop
);
1238 if( lpDrop
&& (win_data
= X11DRV_get_win_data( hWnd
)))
1240 lpDrop
->pFiles
= sizeof(DROPFILES
);
1244 ( x
< (win_data
->client_rect
.left
- win_data
->whole_rect
.left
) ||
1245 y
< (win_data
->client_rect
.top
- win_data
->whole_rect
.top
) ||
1246 x
> (win_data
->client_rect
.right
- win_data
->whole_rect
.left
) ||
1247 y
> (win_data
->client_rect
.bottom
- win_data
->whole_rect
.top
) );
1248 lpDrop
->fWide
= FALSE
;
1249 p_drop
= (char*)(lpDrop
+ 1);
1252 /* create message content */
1255 next
= strchr(p
, '\n');
1258 if (strncmp(p
,"file:",5) == 0 ) {
1259 INT len
= GetShortPathNameA( p
+5, p_drop
, 65535 );
1261 TRACE("drop file %s as %s\n", p
+5, p_drop
);
1264 WARN("can't convert file %s to dos name\n", p
+5);
1267 WARN("unknown mime type %s\n", p
);
1272 next
= strchr(p
, '\n');
1279 GlobalUnlock(hDrop
);
1280 PostMessageA( hWnd
, WM_DROPFILES
, (WPARAM
)hDrop
, 0L );
1284 if( p_data
) XFree(p_data
);
1285 wine_tsx11_unlock();
1289 /**********************************************************************
1290 * handle_dnd_protocol
1292 static void handle_dnd_protocol( HWND hwnd
, XClientMessageEvent
*event
)
1295 int root_x
, root_y
, child_x
, child_y
;
1298 /* query window (drag&drop event contains only drag window) */
1300 XQueryPointer( event
->display
, root_window
, &root
, &child
,
1301 &root_x
, &root_y
, &child_x
, &child_y
, &u
);
1302 if (XFindContext( event
->display
, child
, winContext
, (char **)&hwnd
) != 0) hwnd
= 0;
1303 wine_tsx11_unlock();
1305 if (event
->data
.l
[0] == DndFile
|| event
->data
.l
[0] == DndFiles
)
1306 EVENT_DropFromOffiX(hwnd
, event
);
1307 else if (event
->data
.l
[0] == DndURL
)
1308 EVENT_DropURLs(hwnd
, event
);
1312 struct client_message_handler
1314 int atom
; /* protocol atom */
1315 void (*handler
)(HWND
, XClientMessageEvent
*); /* corresponding handler function */
1318 static const struct client_message_handler client_messages
[] =
1320 { XATOM_WM_PROTOCOLS
, handle_wm_protocols
},
1321 { XATOM_DndProtocol
, handle_dnd_protocol
},
1322 { XATOM_XdndEnter
, X11DRV_XDND_EnterEvent
},
1323 { XATOM_XdndPosition
, X11DRV_XDND_PositionEvent
},
1324 { XATOM_XdndDrop
, X11DRV_XDND_DropEvent
},
1325 { XATOM_XdndLeave
, X11DRV_XDND_LeaveEvent
}
1329 /**********************************************************************
1330 * X11DRV_ClientMessage
1332 static void X11DRV_ClientMessage( HWND hwnd
, XEvent
*xev
)
1334 XClientMessageEvent
*event
= &xev
->xclient
;
1339 if (event
->format
!= 32)
1341 WARN( "Don't know how to handle format %d\n", event
->format
);
1345 for (i
= 0; i
< sizeof(client_messages
)/sizeof(client_messages
[0]); i
++)
1347 if (event
->message_type
== X11DRV_Atoms
[client_messages
[i
].atom
- FIRST_XATOM
])
1349 client_messages
[i
].handler( hwnd
, event
);
1353 TRACE( "no handler found for %ld\n", event
->message_type
);
1357 /***********************************************************************
1358 * X11DRV_SendInput (X11DRV.@)
1360 UINT
X11DRV_SendInput( UINT count
, LPINPUT inputs
, int size
)
1364 for (i
= 0; i
< count
; i
++, inputs
++)
1366 switch(inputs
->type
)
1369 X11DRV_send_mouse_input( 0, inputs
->u
.mi
.dwFlags
, inputs
->u
.mi
.dx
, inputs
->u
.mi
.dy
,
1370 inputs
->u
.mi
.mouseData
, inputs
->u
.mi
.time
,
1371 inputs
->u
.mi
.dwExtraInfo
, LLMHF_INJECTED
);
1373 case INPUT_KEYBOARD
:
1374 X11DRV_send_keyboard_input( inputs
->u
.ki
.wVk
, inputs
->u
.ki
.wScan
, inputs
->u
.ki
.dwFlags
,
1375 inputs
->u
.ki
.time
, inputs
->u
.ki
.dwExtraInfo
, LLKHF_INJECTED
);
1377 case INPUT_HARDWARE
:
1378 FIXME( "INPUT_HARDWARE not supported\n" );