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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #define COM_NO_WINDOWS_H
25 #include <X11/Xatom.h>
26 #include <X11/keysym.h>
28 #include <X11/Xresource.h>
29 #include <X11/Xutil.h>
30 #ifdef HAVE_LIBXXF86DGA2
31 #include <X11/extensions/xf86dga.h>
37 #include "wine/winuser16.h"
42 #include "shlobj.h" /* DROPFILES */
49 #include "wine/debug.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(event
);
52 WINE_DECLARE_DEBUG_CHANNEL(clipboard
);
54 /* X context to associate a hwnd to an X window */
55 extern XContext winContext
;
57 extern BOOL ximInComposeMode
;
59 #define DndNotDnd -1 /* OffiX drag&drop */
71 #define DndURL 128 /* KDE drag&drop */
73 static const char * const event_names
[] =
75 "", "", "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease",
76 "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut",
77 "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify",
78 "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",
79 "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify",
80 "ResizeRequest", "CirculateNotify", "CirculateRequest", "PropertyNotify",
81 "SelectionClear", "SelectionRequest", "SelectionNotify", "ColormapNotify",
82 "ClientMessage", "MappingNotify"
86 static void EVENT_ProcessEvent( XEvent
*event
);
89 static void EVENT_FocusIn( HWND hWnd
, XFocusChangeEvent
*event
);
90 static void EVENT_FocusOut( HWND hWnd
, XFocusChangeEvent
*event
);
91 static void EVENT_SelectionRequest( HWND hWnd
, XSelectionRequestEvent
*event
, BOOL bIsMultiple
);
92 static void EVENT_SelectionClear( HWND hWnd
, XSelectionClearEvent
*event
);
93 static void EVENT_PropertyNotify( XPropertyEvent
*event
);
94 static void EVENT_ClientMessage( HWND hWnd
, XClientMessageEvent
*event
);
96 extern void X11DRV_ButtonPress( HWND hwnd
, XButtonEvent
*event
);
97 extern void X11DRV_ButtonRelease( HWND hwnd
, XButtonEvent
*event
);
98 extern void X11DRV_MotionNotify( HWND hwnd
, XMotionEvent
*event
);
99 extern void X11DRV_EnterNotify( HWND hwnd
, XCrossingEvent
*event
);
100 extern void X11DRV_KeyEvent( HWND hwnd
, XKeyEvent
*event
);
101 extern void X11DRV_KeymapNotify( HWND hwnd
, XKeymapEvent
*event
);
102 extern void X11DRV_Expose( HWND hwnd
, XExposeEvent
*event
);
103 extern void X11DRV_MapNotify( HWND hwnd
, XMapEvent
*event
);
104 extern void X11DRV_UnmapNotify( HWND hwnd
, XUnmapEvent
*event
);
105 extern void X11DRV_ConfigureNotify( HWND hwnd
, XConfigureEvent
*event
);
106 extern void X11DRV_MappingNotify( XMappingEvent
*event
);
108 #ifdef HAVE_LIBXXF86DGA2
109 static int DGAMotionEventType
;
110 static int DGAButtonPressEventType
;
111 static int DGAButtonReleaseEventType
;
112 static int DGAKeyPressEventType
;
113 static int DGAKeyReleaseEventType
;
115 static BOOL DGAUsed
= FALSE
;
116 static HWND DGAhwnd
= 0;
118 extern void X11DRV_DGAMotionEvent( HWND hwnd
, XDGAMotionEvent
*event
);
119 extern void X11DRV_DGAButtonPressEvent( HWND hwnd
, XDGAButtonEvent
*event
);
120 extern void X11DRV_DGAButtonReleaseEvent( HWND hwnd
, XDGAButtonEvent
*event
);
123 /* Static used for the current input method */
124 static INPUT_TYPE current_input_type
= X11DRV_INPUT_ABSOLUTE
;
125 static BOOL in_transition
= FALSE
; /* This is not used as for today */
128 /***********************************************************************
131 static int process_events( struct x11drv_thread_data
*data
)
137 while ( XPending( data
->display
) )
141 XNextEvent( data
->display
, &event
);
142 ignore
= XFilterEvent( &event
, None
);
144 if (!ignore
) EVENT_ProcessEvent( &event
);
153 /***********************************************************************
154 * MsgWaitForMultipleObjectsEx (X11DRV.@)
156 DWORD
X11DRV_MsgWaitForMultipleObjectsEx( DWORD count
, const HANDLE
*handles
,
157 DWORD timeout
, DWORD mask
, DWORD flags
)
159 HANDLE new_handles
[MAXIMUM_WAIT_OBJECTS
+1]; /* FIXME! */
161 struct x11drv_thread_data
*data
= NtCurrentTeb()->driver_data
;
163 if (!data
|| data
->process_event_count
)
164 return WaitForMultipleObjectsEx( count
, handles
, flags
& MWMO_WAITALL
,
165 timeout
, flags
& MWMO_ALERTABLE
);
167 /* check whether only server queue handle was passed in */
168 if (count
< 2) flags
&= ~MWMO_WAITALL
;
170 for (i
= 0; i
< count
; i
++) new_handles
[i
] = handles
[i
];
171 new_handles
[count
] = data
->display_fd
;
174 XFlush( gdi_display
);
175 XFlush( data
->display
);
178 data
->process_event_count
++;
179 if (process_events( data
)) ret
= count
;
182 ret
= WaitForMultipleObjectsEx( count
+1, new_handles
, flags
& MWMO_WAITALL
,
183 timeout
, flags
& MWMO_ALERTABLE
);
184 if (ret
== count
) process_events( data
);
186 data
->process_event_count
--;
191 /***********************************************************************
194 * Process an X event.
196 static void EVENT_ProcessEvent( XEvent
*event
)
199 Display
*display
= event
->xany
.display
;
201 TRACE( "called.\n" );
205 case SelectionNotify
: /* all of these should be caught by XCheckTypedWindowEvent() */
206 FIXME("Got SelectionNotify - must not happen!\n");
209 /* We get all these because of StructureNotifyMask.
210 This check is placed here to avoid getting error messages below,
211 as X might send some of these even for windows that have already
213 case CirculateNotify
:
221 #ifdef HAVE_LIBXXF86DGA2
223 if (event
->type
== DGAMotionEventType
) {
224 TRACE("DGAMotionEvent received.\n");
225 X11DRV_DGAMotionEvent( DGAhwnd
, (XDGAMotionEvent
*)event
);
228 if (event
->type
== DGAButtonPressEventType
) {
229 TRACE("DGAButtonPressEvent received.\n");
230 X11DRV_DGAButtonPressEvent( DGAhwnd
, (XDGAButtonEvent
*)event
);
233 if (event
->type
== DGAButtonReleaseEventType
) {
234 TRACE("DGAButtonReleaseEvent received.\n");
235 X11DRV_DGAButtonReleaseEvent( DGAhwnd
, (XDGAButtonEvent
*)event
);
238 if ((event
->type
== DGAKeyPressEventType
) ||
239 (event
->type
== DGAKeyReleaseEventType
)) {
240 /* Fill a XKeyEvent to send to EVENT_Key */
242 XDGAKeyEvent
*evt
= (XDGAKeyEvent
*) event
;
244 TRACE("DGAKeyPress/ReleaseEvent received.\n");
246 if (evt
->type
== DGAKeyReleaseEventType
)
247 ke
.type
= KeyRelease
;
250 ke
.serial
= evt
->serial
;
251 ke
.send_event
= FALSE
;
252 ke
.display
= evt
->display
;
261 ke
.state
= evt
->state
;
262 ke
.keycode
= evt
->keycode
;
263 ke
.same_screen
= TRUE
;
264 X11DRV_KeyEvent( 0, &ke
);
271 if (XFindContext( display
, event
->xany
.window
, winContext
, (char **)&hWnd
) != 0)
272 hWnd
= 0; /* Not for a registered window */
274 if (!hWnd
&& event
->xany
.window
== root_window
) hWnd
= GetDesktopWindow();
276 if (!hWnd
&& event
->type
!= PropertyNotify
&&
277 event
->type
!= MappingNotify
&& event
->type
!= KeymapNotify
)
278 WARN( "Got event %s for unknown Window %08lx\n",
279 event_names
[event
->type
], event
->xany
.window
);
280 else if (event
->type
<= MappingNotify
)
281 TRACE("Got event %s for hwnd/window %p/%lx, GetFocus()=%p\n",
282 event_names
[event
->type
], hWnd
, event
->xany
.window
, GetFocus() );
284 TRACE("Got extension event for hwnd/window %p/%lx, GetFocus()=%p\n",
285 hWnd
, event
->xany
.window
, GetFocus() );
287 if (X11DRV_ProcessTabletEvent(hWnd
, event
))
289 TRACE("Return: filtered by tablet\n");
297 /* FIXME: should generate a motion event if event point is different from current pos */
298 X11DRV_KeyEvent( hWnd
, (XKeyEvent
*)event
);
302 X11DRV_ButtonPress( hWnd
, (XButtonEvent
*)event
);
306 X11DRV_ButtonRelease( hWnd
, (XButtonEvent
*)event
);
310 X11DRV_MotionNotify( hWnd
, (XMotionEvent
*)event
);
314 X11DRV_EnterNotify( hWnd
, (XCrossingEvent
*)event
);
318 EVENT_FocusIn( hWnd
, (XFocusChangeEvent
*)event
);
322 EVENT_FocusOut( hWnd
, (XFocusChangeEvent
*)event
);
326 X11DRV_Expose( hWnd
, &event
->xexpose
);
329 case ConfigureNotify
:
331 X11DRV_ConfigureNotify( hWnd
, &event
->xconfigure
);
334 case SelectionRequest
:
336 EVENT_SelectionRequest( hWnd
, (XSelectionRequestEvent
*)event
, FALSE
);
341 EVENT_SelectionClear( hWnd
, (XSelectionClearEvent
*) event
);
345 EVENT_PropertyNotify( (XPropertyEvent
*)event
);
350 EVENT_ClientMessage( hWnd
, (XClientMessageEvent
*) event
);
357 X11DRV_MapNotify( hWnd
, (XMapEvent
*)event
);
361 X11DRV_UnmapNotify( hWnd
, (XUnmapEvent
*)event
);
365 X11DRV_KeymapNotify( hWnd
, (XKeymapEvent
*)event
);
369 X11DRV_MappingNotify( (XMappingEvent
*) event
);
373 WARN("Unprocessed event %s for hwnd %p\n", event_names
[event
->type
], hWnd
);
376 TRACE( "returns.\n" );
380 /*******************************************************************
381 * can_activate_window
383 * Check if we can activate the specified window.
385 inline static BOOL
can_activate_window( HWND hwnd
)
387 LONG style
= GetWindowLongW( hwnd
, GWL_STYLE
);
388 if (!(style
& WS_VISIBLE
)) return FALSE
;
389 if ((style
& (WS_POPUP
|WS_CHILD
)) == WS_CHILD
) return FALSE
;
390 return !(style
& WS_DISABLED
);
394 /**********************************************************************
397 static void set_focus( HWND hwnd
, Time time
)
402 TRACE( "setting foreground window to %p\n", hwnd
);
403 SetForegroundWindow( hwnd
);
406 if (focus
) focus
= GetAncestor( focus
, GA_ROOT
);
407 win
= X11DRV_get_whole_window(focus
);
411 TRACE( "setting focus to %p (%lx) time=%ld\n", focus
, win
, time
);
413 XSetInputFocus( thread_display(), win
, RevertToParent
, time
);
419 /**********************************************************************
420 * handle_wm_protocols_message
422 static void handle_wm_protocols_message( HWND hwnd
, XClientMessageEvent
*event
)
424 Atom protocol
= (Atom
)event
->data
.l
[0];
426 if (!protocol
) return;
428 if (protocol
== x11drv_atom(WM_DELETE_WINDOW
))
430 /* Ignore the delete window request if the window has been disabled
431 * and we are in managed mode. This is to disallow applications from
432 * being closed by the window manager while in a modal state.
434 if (IsWindowEnabled(hwnd
)) PostMessageW( hwnd
, WM_SYSCOMMAND
, SC_CLOSE
, 0 );
436 else if (protocol
== x11drv_atom(WM_TAKE_FOCUS
))
438 Time event_time
= (Time
)event
->data
.l
[1];
439 HWND last_focus
= x11drv_thread_data()->last_focus
;
441 TRACE( "got take focus msg for %p, enabled=%d, focus=%p, active=%p, fg=%p, last=%p\n",
442 hwnd
, IsWindowEnabled(hwnd
), GetFocus(), GetActiveWindow(),
443 GetForegroundWindow(), last_focus
);
445 if (can_activate_window(hwnd
))
447 /* simulate a mouse click on the caption to find out
448 * whether the window wants to be activated */
449 LRESULT ma
= SendMessageW( hwnd
, WM_MOUSEACTIVATE
,
450 (WPARAM
)GetAncestor( hwnd
, GA_ROOT
),
451 MAKELONG(HTCAPTION
,WM_LBUTTONDOWN
) );
452 if (ma
!= MA_NOACTIVATEANDEAT
&& ma
!= MA_NOACTIVATE
) set_focus( hwnd
, event_time
);
453 else TRACE( "not setting focus to %p (%lx), ma=%ld\n", hwnd
, event
->window
, ma
);
458 if (hwnd
) hwnd
= GetAncestor( hwnd
, GA_ROOT
);
459 if (!hwnd
) hwnd
= GetActiveWindow();
460 if (!hwnd
) hwnd
= last_focus
;
461 if (hwnd
&& can_activate_window(hwnd
)) set_focus( hwnd
, event_time
);
464 else if (protocol
== x11drv_atom(_NET_WM_PING
))
466 XClientMessageEvent xev
;
469 TRACE("NET_WM Ping\n");
470 xev
.window
= DefaultRootWindow(xev
.display
);
471 XSendEvent(xev
.display
, xev
.window
, False
, SubstructureRedirectMask
| SubstructureNotifyMask
, (XEvent
*)&xev
);
472 /* this line is semi-stolen from gtk2 */
473 TRACE("NET_WM Pong\n");
478 static const char * const focus_details
[] =
484 "NotifyNonlinearVirtual",
490 /**********************************************************************
493 static void EVENT_FocusIn( HWND hwnd
, XFocusChangeEvent
*event
)
499 TRACE( "win %p xwin %lx detail=%s\n", hwnd
, event
->window
, focus_details
[event
->detail
] );
501 if (event
->detail
== NotifyPointer
) return;
503 if ((xic
= X11DRV_get_ic( hwnd
)))
509 if (use_take_focus
) return; /* ignore FocusIn if we are using take focus */
511 if (!can_activate_window(hwnd
))
513 HWND hwnd
= GetFocus();
514 if (hwnd
) hwnd
= GetAncestor( hwnd
, GA_ROOT
);
515 if (!hwnd
) hwnd
= GetActiveWindow();
516 if (!hwnd
) hwnd
= x11drv_thread_data()->last_focus
;
517 if (hwnd
&& can_activate_window(hwnd
)) set_focus( hwnd
, CurrentTime
);
519 else SetForegroundWindow( hwnd
);
523 /**********************************************************************
526 * Note: only top-level windows get FocusOut events.
528 static void EVENT_FocusOut( HWND hwnd
, XFocusChangeEvent
*event
)
535 TRACE( "win %p xwin %lx detail=%s\n", hwnd
, event
->window
, focus_details
[event
->detail
] );
537 if (event
->detail
== NotifyPointer
) return;
538 if (ximInComposeMode
) return;
540 x11drv_thread_data()->last_focus
= hwnd
;
541 if ((xic
= X11DRV_get_ic( hwnd
)))
544 XUnsetICFocus( xic
);
547 if (hwnd
!= GetForegroundWindow()) return;
548 SendMessageA( hwnd
, WM_CANCELMODE
, 0, 0 );
550 /* don't reset the foreground window, if the window which is
551 getting the focus is a Wine window */
554 XGetInputFocus( thread_display(), &focus_win
, &revert
);
557 if (XFindContext( thread_display(), focus_win
, winContext
, (char **)&hwnd_tmp
) != 0)
564 /* Abey : 6-Oct-99. Check again if the focus out window is the
565 Foreground window, because in most cases the messages sent
566 above must have already changed the foreground window, in which
567 case we don't have to change the foreground window to 0 */
568 if (hwnd
== GetForegroundWindow())
570 TRACE( "lost focus, setting fg to 0\n" );
571 SetForegroundWindow( 0 );
577 /***********************************************************************
578 * EVENT_SelectionRequest_AddTARGETS
579 * Utility function for EVENT_SelectionRequest_TARGETS.
581 static BOOL
EVENT_SelectionRequest_AddTARGETS(Atom
* targets
, unsigned long cTargets
, Atom prop
)
586 /* Scan through what we have so far to avoid duplicates */
587 for (i
= 0, bExists
= FALSE
; i
< cTargets
; i
++)
589 if (targets
[i
] == prop
)
597 targets
[cTargets
] = prop
;
603 /***********************************************************************
604 * EVENT_SelectionRequest_TARGETS
605 * Service a TARGETS selection request event
607 static Atom
EVENT_SelectionRequest_TARGETS( Display
*display
, Window requestor
,
608 Atom target
, Atom rprop
)
614 LPWINE_CLIPFORMAT lpFormat
;
617 * Count the number of items we wish to expose as selection targets.
618 * We include the TARGETS item, and property aliases
620 cTargets
= X11DRV_CountClipboardFormats() + 1;
622 for (wFormat
= 0; (wFormat
= X11DRV_EnumClipboardFormats(wFormat
));)
624 lpFormat
= X11DRV_CLIPBOARD_LookupFormat(wFormat
);
628 if (!lpFormat
->lpDrvExportFunc
)
631 if (X11DRV_CLIPBOARD_LookupPropertyAlias(lpFormat
->drvData
))
634 /* else most likely unregistered format such as CF_PRIVATE or CF_GDIOBJ */
637 TRACE_(clipboard
)(" found %ld formats\n", cTargets
);
639 /* Allocate temp buffer */
640 targets
= (Atom
*)HeapAlloc( GetProcessHeap(), 0, cTargets
* sizeof(Atom
));
644 /* Create TARGETS property list (First item in list is TARGETS itself) */
645 for (targets
[0] = x11drv_atom(TARGETS
), cTargets
= 1, wFormat
= 0;
646 (wFormat
= X11DRV_EnumClipboardFormats(wFormat
));)
648 lpFormat
= X11DRV_CLIPBOARD_LookupFormat(wFormat
);
652 if (lpFormat
->lpDrvExportFunc
)
654 if (EVENT_SelectionRequest_AddTARGETS(targets
, cTargets
, lpFormat
->drvData
))
658 /* Check if any alias should be listed */
659 alias
= X11DRV_CLIPBOARD_LookupPropertyAlias(lpFormat
->drvData
);
662 if (EVENT_SelectionRequest_AddTARGETS(targets
, cTargets
, alias
))
670 if (TRACE_ON(clipboard
))
673 for ( i
= 0; i
< cTargets
; i
++)
677 char *itemFmtName
= XGetAtomName(display
, targets
[i
]);
678 TRACE_(clipboard
)("\tAtom# %d: Property %ld Type %s\n", i
, targets
[i
], itemFmtName
);
684 /* We may want to consider setting the type to xaTargets instead,
685 * in case some apps expect this instead of XA_ATOM */
686 XChangeProperty(display
, requestor
, rprop
, XA_ATOM
, 32,
687 PropModeReplace
, (unsigned char *)targets
, cTargets
);
690 HeapFree(GetProcessHeap(), 0, targets
);
696 /***********************************************************************
697 * EVENT_SelectionRequest_MULTIPLE
698 * Service a MULTIPLE selection request event
699 * rprop contains a list of (target,property) atom pairs.
700 * The first atom names a target and the second names a property.
701 * The effect is as if we have received a sequence of SelectionRequest events
702 * (one for each atom pair) except that:
703 * 1. We reply with a SelectionNotify only when all the requested conversions
704 * have been performed.
705 * 2. If we fail to convert the target named by an atom in the MULTIPLE property,
706 * we replace the atom in the property by None.
708 static Atom
EVENT_SelectionRequest_MULTIPLE( HWND hWnd
, XSelectionRequestEvent
*pevent
)
710 Display
*display
= pevent
->display
;
712 Atom atype
=AnyPropertyType
;
714 unsigned long remain
;
715 Atom
* targetPropList
=NULL
;
716 unsigned long cTargetPropList
= 0;
718 /* If the specified property is None the requestor is an obsolete client.
719 * We support these by using the specified target atom as the reply property.
721 rprop
= pevent
->property
;
723 rprop
= pevent
->target
;
727 /* Read the MULTIPLE property contents. This should contain a list of
728 * (target,property) atom pairs.
731 if(XGetWindowProperty(display
, pevent
->requestor
, rprop
,
732 0, 0x3FFF, False
, AnyPropertyType
, &atype
,&aformat
,
733 &cTargetPropList
, &remain
,
734 (unsigned char**)&targetPropList
) != Success
)
737 TRACE("\tCouldn't read MULTIPLE property\n");
741 TRACE("\tType %s,Format %d,nItems %ld, Remain %ld\n",
742 XGetAtomName(display
, atype
), aformat
, cTargetPropList
, remain
);
746 * Make sure we got what we expect.
747 * NOTE: According to the X-ICCCM Version 2.0 documentation the property sent
748 * in a MULTIPLE selection request should be of type ATOM_PAIR.
749 * However some X apps(such as XPaint) are not compliant with this and return
750 * a user defined atom in atype when XGetWindowProperty is called.
751 * The data *is* an atom pair but is not denoted as such.
753 if(aformat
== 32 /* atype == xAtomPair */ )
757 /* Iterate through the ATOM_PAIR list and execute a SelectionRequest
758 * for each (target,property) pair */
760 for (i
= 0; i
< cTargetPropList
; i
+=2)
762 XSelectionRequestEvent event
;
766 char *targetName
, *propName
;
768 targetName
= XGetAtomName(display
, targetPropList
[i
]);
769 propName
= XGetAtomName(display
, targetPropList
[i
+1]);
770 TRACE("MULTIPLE(%d): Target='%s' Prop='%s'\n",
771 i
/2, targetName
, propName
);
777 /* We must have a non "None" property to service a MULTIPLE target atom */
778 if ( !targetPropList
[i
+1] )
780 TRACE("\tMULTIPLE(%d): Skipping target with empty property!\n", i
);
784 /* Set up an XSelectionRequestEvent for this (target,property) pair */
785 memcpy( &event
, pevent
, sizeof(XSelectionRequestEvent
) );
786 event
.target
= targetPropList
[i
];
787 event
.property
= targetPropList
[i
+1];
789 /* Fire a SelectionRequest, informing the handler that we are processing
790 * a MULTIPLE selection request event.
792 EVENT_SelectionRequest( hWnd
, &event
, TRUE
);
796 /* Free the list of targets/properties */
798 XFree(targetPropList
);
807 /***********************************************************************
808 * EVENT_SelectionRequest
809 * Process an event selection request event.
810 * The bIsMultiple flag is used to signal when EVENT_SelectionRequest is called
811 * recursively while servicing a "MULTIPLE" selection target.
813 * Note: We only receive this event when WINE owns the X selection
815 static void EVENT_SelectionRequest( HWND hWnd
, XSelectionRequestEvent
*event
, BOOL bIsMultiple
)
817 Display
*display
= event
->display
;
818 XSelectionEvent result
;
820 Window request
= event
->requestor
;
822 TRACE_(clipboard
)("\n");
825 * We can only handle the selection request if :
826 * The selection is PRIMARY or CLIPBOARD, AND we can successfully open the clipboard.
827 * Don't do these checks or open the clipboard while recursively processing MULTIPLE,
828 * since this has been already done.
832 if (((event
->selection
!= XA_PRIMARY
) && (event
->selection
!= x11drv_atom(CLIPBOARD
))))
836 /* If the specified property is None the requestor is an obsolete client.
837 * We support these by using the specified target atom as the reply property.
839 rprop
= event
->property
;
841 rprop
= event
->target
;
843 if(event
->target
== x11drv_atom(TARGETS
)) /* Return a list of all supported targets */
845 /* TARGETS selection request */
846 rprop
= EVENT_SelectionRequest_TARGETS( display
, request
, event
->target
, rprop
);
848 else if(event
->target
== x11drv_atom(MULTIPLE
)) /* rprop contains a list of (target, property) atom pairs */
850 /* MULTIPLE selection request */
851 rprop
= EVENT_SelectionRequest_MULTIPLE( hWnd
, event
);
855 LPWINE_CLIPFORMAT lpFormat
= X11DRV_CLIPBOARD_LookupProperty(event
->target
);
858 lpFormat
= X11DRV_CLIPBOARD_LookupAliasProperty(event
->target
);
860 if (lpFormat
&& lpFormat
->lpDrvExportFunc
)
862 LPWINE_CLIPDATA lpData
= X11DRV_CLIPBOARD_LookupData(lpFormat
->wFormatID
);
866 unsigned char* lpClipData
;
868 HANDLE hClipData
= lpFormat
->lpDrvExportFunc(request
, event
->target
,
869 rprop
, lpData
, &cBytes
);
871 if (hClipData
&& (lpClipData
= GlobalLock(hClipData
)))
873 TRACE_(clipboard
)("\tUpdating property %s, %ld bytes\n",
874 lpFormat
->Name
, cBytes
);
877 XChangeProperty(display
, request
, rprop
, event
->target
,
878 8, PropModeReplace
, (unsigned char *)lpClipData
, cBytes
);
881 GlobalUnlock(hClipData
);
882 GlobalFree(hClipData
);
890 * SelectionNotify should be sent only at the end of a MULTIPLE request
894 result
.type
= SelectionNotify
;
895 result
.display
= display
;
896 result
.requestor
= request
;
897 result
.selection
= event
->selection
;
898 result
.property
= rprop
;
899 result
.target
= event
->target
;
900 result
.time
= event
->time
;
901 TRACE("Sending SelectionNotify event...\n");
903 XSendEvent(display
,event
->requestor
,False
,NoEventMask
,(XEvent
*)&result
);
908 /***********************************************************************
909 * EVENT_SelectionClear
911 static void EVENT_SelectionClear( HWND hWnd
, XSelectionClearEvent
*event
)
913 if (event
->selection
== XA_PRIMARY
|| event
->selection
== x11drv_atom(CLIPBOARD
))
914 X11DRV_CLIPBOARD_ReleaseSelection( event
->selection
, event
->window
, hWnd
);
917 /***********************************************************************
918 * EVENT_PropertyNotify
919 * We use this to release resources like Pixmaps when a selection
920 * client no longer needs them.
922 static void EVENT_PropertyNotify( XPropertyEvent
*event
)
924 /* Check if we have any resources to free */
925 TRACE("Received PropertyNotify event: \n");
931 TRACE("\tPropertyDelete for atom %ld on window %ld\n",
932 event
->atom
, (long)event
->window
);
936 case PropertyNewValue
:
938 TRACE("\tPropertyNewValue for atom %ld on window %ld\n\n",
939 event
->atom
, (long)event
->window
);
948 static HWND
find_drop_window( HWND hQueryWnd
, LPPOINT lpPt
)
952 if (!IsWindowEnabled(hQueryWnd
)) return 0;
954 GetWindowRect(hQueryWnd
, &tempRect
);
956 if(!PtInRect(&tempRect
, *lpPt
)) return 0;
958 if (!IsIconic( hQueryWnd
))
960 GetClientRect( hQueryWnd
, &tempRect
);
961 MapWindowPoints( hQueryWnd
, 0, (LPPOINT
)&tempRect
, 2 );
963 if (PtInRect( &tempRect
, *lpPt
))
965 HWND
*list
= WIN_ListChildren( hQueryWnd
);
972 for (i
= 0; list
[i
]; i
++)
974 if (GetWindowLongW( list
[i
], GWL_STYLE
) & WS_VISIBLE
)
976 GetWindowRect( list
[i
], &tempRect
);
977 if (PtInRect( &tempRect
, *lpPt
)) break;
982 if (IsWindowEnabled( list
[i
] ))
983 bResult
= find_drop_window( list
[i
], lpPt
);
985 HeapFree( GetProcessHeap(), 0, list
);
987 if(bResult
) return bResult
;
991 if(!(GetWindowLongA( hQueryWnd
, GWL_EXSTYLE
) & WS_EX_ACCEPTFILES
)) return 0;
993 ScreenToClient(hQueryWnd
, lpPt
);
998 /**********************************************************************
999 * EVENT_DropFromOffix
1001 * don't know if it still works (last Changlog is from 96/11/04)
1003 static void EVENT_DropFromOffiX( HWND hWnd
, XClientMessageEvent
*event
)
1005 unsigned long data_length
;
1006 unsigned long aux_long
;
1007 unsigned char* p_data
= NULL
;
1018 Window w_aux_root
, w_aux_child
;
1022 pWnd
= WIN_FindWndPtr(hWnd
);
1025 XQueryPointer( event
->display
, get_whole_window(pWnd
), &w_aux_root
, &w_aux_child
,
1026 &x
, &y
, (int *) &u
.pt_aux
.x
, (int *) &u
.pt_aux
.y
,
1027 (unsigned int*)&aux_long
);
1028 wine_tsx11_unlock();
1030 /* find out drop point and drop window */
1031 if( x
< 0 || y
< 0 ||
1032 x
> (pWnd
->rectWindow
.right
- pWnd
->rectWindow
.left
) ||
1033 y
> (pWnd
->rectWindow
.bottom
- pWnd
->rectWindow
.top
) )
1035 bAccept
= pWnd
->dwExStyle
& WS_EX_ACCEPTFILES
;
1041 POINT pt
= { x
, y
};
1042 HWND hwndDrop
= find_drop_window( hWnd
, &pt
);
1055 WIN_ReleaseWndPtr(pWnd
);
1057 if (!bAccept
) return;
1060 XGetWindowProperty( event
->display
, DefaultRootWindow(event
->display
),
1061 x11drv_atom(DndSelection
), 0, 65535, FALSE
,
1062 AnyPropertyType
, &u
.atom_aux
, (int *) &u
.pt_aux
.y
,
1063 &data_length
, &aux_long
, &p_data
);
1064 wine_tsx11_unlock();
1066 if( !aux_long
&& p_data
) /* don't bother if > 64K */
1068 signed char *p
= (signed char*) p_data
;
1072 while( *p
) /* calculate buffer size */
1075 if((u
.i
= *p
) != -1 )
1077 INT len
= GetShortPathNameA( p
, NULL
, 0 );
1078 if (len
) aux_long
+= len
+ 1;
1083 if( aux_long
&& aux_long
< 65535 )
1088 aux_long
+= sizeof(DROPFILES
) + 1;
1089 hDrop
= GlobalAlloc( GMEM_SHARE
, aux_long
);
1090 lpDrop
= (DROPFILES
*)GlobalLock( hDrop
);
1094 WND
*pDropWnd
= WIN_FindWndPtr( hScope
);
1095 lpDrop
->pFiles
= sizeof(DROPFILES
);
1099 ( x
< (pDropWnd
->rectClient
.left
- pDropWnd
->rectWindow
.left
) ||
1100 y
< (pDropWnd
->rectClient
.top
- pDropWnd
->rectWindow
.top
) ||
1101 x
> (pDropWnd
->rectClient
.right
- pDropWnd
->rectWindow
.left
) ||
1102 y
> (pDropWnd
->rectClient
.bottom
- pDropWnd
->rectWindow
.top
) );
1103 lpDrop
->fWide
= FALSE
;
1104 WIN_ReleaseWndPtr(pDropWnd
);
1105 p_drop
= (char *)(lpDrop
+ 1);
1109 if( *p
!= -1 ) /* use only "good" entries */
1111 GetShortPathNameA( p
, p_drop
, 65535 );
1112 p_drop
+= strlen( p_drop
) + 1;
1117 PostMessageA( hWnd
, WM_DROPFILES
, (WPARAM
)hDrop
, 0L );
1122 if( p_data
) XFree(p_data
);
1123 wine_tsx11_unlock();
1126 /**********************************************************************
1129 * drop items are separated by \n
1130 * each item is prefixed by its mime type
1132 * event->data.l[3], event->data.l[4] contains drop x,y position
1134 static void EVENT_DropURLs( HWND hWnd
, XClientMessageEvent
*event
)
1136 unsigned long data_length
;
1137 unsigned long aux_long
, drop_len
= 0;
1138 unsigned char *p_data
= NULL
; /* property data */
1139 char *p_drop
= NULL
;
1150 if (!(GetWindowLongW( hWnd
, GWL_EXSTYLE
) & WS_EX_ACCEPTFILES
)) return;
1153 XGetWindowProperty( event
->display
, DefaultRootWindow(event
->display
),
1154 x11drv_atom(DndSelection
), 0, 65535, FALSE
,
1155 AnyPropertyType
, &u
.atom_aux
, &u
.i
,
1156 &data_length
, &aux_long
, &p_data
);
1157 wine_tsx11_unlock();
1159 WARN("property too large, truncated!\n");
1160 TRACE("urls=%s\n", p_data
);
1162 if( !aux_long
&& p_data
) { /* don't bother if > 64K */
1163 /* calculate length */
1165 next
= strchr(p
, '\n');
1168 if (strncmp(p
,"file:",5) == 0 ) {
1169 INT len
= GetShortPathNameA( p
+5, NULL
, 0 );
1170 if (len
) drop_len
+= len
+ 1;
1175 next
= strchr(p
, '\n');
1181 if( drop_len
&& drop_len
< 65535 ) {
1183 XQueryPointer( event
->display
, root_window
, &u
.w_aux
, &u
.w_aux
,
1184 &x
, &y
, &u
.i
, &u
.i
, &u
.i
);
1185 wine_tsx11_unlock();
1187 drop_len
+= sizeof(DROPFILES
) + 1;
1188 hDrop
= GlobalAlloc( GMEM_SHARE
, drop_len
);
1189 lpDrop
= (DROPFILES
*) GlobalLock( hDrop
);
1192 WND
*pDropWnd
= WIN_FindWndPtr( hWnd
);
1193 lpDrop
->pFiles
= sizeof(DROPFILES
);
1194 lpDrop
->pt
.x
= (INT
)x
;
1195 lpDrop
->pt
.y
= (INT
)y
;
1197 ( x
< (pDropWnd
->rectClient
.left
- pDropWnd
->rectWindow
.left
) ||
1198 y
< (pDropWnd
->rectClient
.top
- pDropWnd
->rectWindow
.top
) ||
1199 x
> (pDropWnd
->rectClient
.right
- pDropWnd
->rectWindow
.left
) ||
1200 y
> (pDropWnd
->rectClient
.bottom
- pDropWnd
->rectWindow
.top
) );
1201 lpDrop
->fWide
= FALSE
;
1202 p_drop
= (char*)(lpDrop
+ 1);
1203 WIN_ReleaseWndPtr(pDropWnd
);
1206 /* create message content */
1209 next
= strchr(p
, '\n');
1212 if (strncmp(p
,"file:",5) == 0 ) {
1213 INT len
= GetShortPathNameA( p
+5, p_drop
, 65535 );
1215 TRACE("drop file %s as %s\n", p
+5, p_drop
);
1218 WARN("can't convert file %s to dos name \n", p
+5);
1221 WARN("unknown mime type %s\n", p
);
1226 next
= strchr(p
, '\n');
1233 GlobalUnlock(hDrop
);
1234 PostMessageA( hWnd
, WM_DROPFILES
, (WPARAM
)hDrop
, 0L );
1238 if( p_data
) XFree(p_data
);
1239 wine_tsx11_unlock();
1243 /**********************************************************************
1244 * EVENT_ClientMessage
1246 static void EVENT_ClientMessage( HWND hWnd
, XClientMessageEvent
*event
)
1248 if (event
->message_type
!= None
&& event
->format
== 32) {
1249 if (event
->message_type
== x11drv_atom(WM_PROTOCOLS
))
1250 handle_wm_protocols_message( hWnd
, event
);
1251 else if (event
->message_type
== x11drv_atom(DndProtocol
))
1253 /* query window (drag&drop event contains only drag window) */
1255 int root_x
, root_y
, child_x
, child_y
;
1259 XQueryPointer( event
->display
, root_window
, &root
, &child
,
1260 &root_x
, &root_y
, &child_x
, &child_y
, &u
);
1261 if (XFindContext( event
->display
, child
, winContext
, (char **)&hWnd
) != 0) hWnd
= 0;
1262 wine_tsx11_unlock();
1264 if (event
->data
.l
[0] == DndFile
|| event
->data
.l
[0] == DndFiles
)
1265 EVENT_DropFromOffiX(hWnd
, event
);
1266 else if (event
->data
.l
[0] == DndURL
)
1267 EVENT_DropURLs(hWnd
, event
);
1269 else if (!X11DRV_XDND_Event(hWnd
, event
))
1272 /* enable this if you want to see the message */
1273 unsigned char* p_data
= NULL
;
1280 XGetWindowProperty( event
->display
, DefaultRootWindow(event
->display
),
1281 dndSelection
, 0, 65535, FALSE
,
1282 AnyPropertyType
, &u
.atom
, &u
.i
,
1283 &u
.l
, &u
.l
, &p_data
);
1284 wine_tsx11_unlock();
1285 TRACE("message_type=%ld, data=%ld,%ld,%ld,%ld,%ld, msg=%s\n",
1286 event
->message_type
, event
->data
.l
[0], event
->data
.l
[1],
1287 event
->data
.l
[2], event
->data
.l
[3], event
->data
.l
[4],
1290 TRACE("unrecognized ClientMessage\n" );
1296 /**********************************************************************
1297 * X11DRV_EVENT_SetInputMethod
1299 INPUT_TYPE
X11DRV_EVENT_SetInputMethod(INPUT_TYPE type
)
1301 INPUT_TYPE prev
= current_input_type
;
1303 /* Flag not used yet */
1304 in_transition
= FALSE
;
1305 current_input_type
= type
;
1310 #ifdef HAVE_LIBXXF86DGA2
1311 /**********************************************************************
1312 * X11DRV_EVENT_SetDGAStatus
1314 void X11DRV_EVENT_SetDGAStatus(HWND hwnd
, int event_base
)
1316 if (event_base
< 0) {
1322 DGAMotionEventType
= event_base
+ MotionNotify
;
1323 DGAButtonPressEventType
= event_base
+ ButtonPress
;
1324 DGAButtonReleaseEventType
= event_base
+ ButtonRelease
;
1325 DGAKeyPressEventType
= event_base
+ KeyPress
;
1326 DGAKeyReleaseEventType
= event_base
+ KeyRelease
;