4 * Copyright 1993 Alexandre Julliard
10 #include <X11/Xatom.h>
11 #include <X11/keysym.h>
14 #include "ts_xresource.h"
19 #ifdef HAVE_LIBXXF86DGA2
20 #include "ts_xf86dga2.h"
26 #include "clipboard.h"
28 #include "debugtools.h"
45 DEFAULT_DEBUG_CHANNEL(event
);
46 DECLARE_DEBUG_CHANNEL(win
);
48 /* X context to associate a hwnd to an X window */
49 extern XContext winContext
;
51 extern Atom wmProtocols
;
52 extern Atom wmDeleteWindow
;
53 extern Atom dndProtocol
;
54 extern Atom dndSelection
;
56 extern void X11DRV_KEYBOARD_UpdateState(void);
57 extern void X11DRV_KEYBOARD_HandleEvent(WND
*pWnd
, XKeyEvent
*event
);
59 #define NB_BUTTONS 5 /* Windows can handle 3 buttons and the wheel too */
62 #define DndNotDnd -1 /* OffiX drag&drop */
74 #define DndURL 128 /* KDE drag&drop */
76 /* The last X window which had the focus */
77 static Window glastXFocusWin
= 0;
79 static const char * const event_names
[] =
81 "", "", "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease",
82 "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut",
83 "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify",
84 "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",
85 "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify",
86 "ResizeRequest", "CirculateNotify", "CirculateRequest", "PropertyNotify",
87 "SelectionClear", "SelectionRequest", "SelectionNotify", "ColormapNotify",
88 "ClientMessage", "MappingNotify"
92 static void CALLBACK
EVENT_Flush( ULONG_PTR arg
);
93 static void CALLBACK
EVENT_ProcessAllEvents( ULONG_PTR arg
);
94 static void EVENT_ProcessEvent( XEvent
*event
);
97 static void EVENT_Key( HWND hWnd
, XKeyEvent
*event
);
98 static void EVENT_ButtonPress( HWND hWnd
, XButtonEvent
*event
);
99 static void EVENT_ButtonRelease( HWND hWnd
, XButtonEvent
*event
);
100 static void EVENT_MotionNotify( HWND hWnd
, XMotionEvent
*event
);
101 static void EVENT_FocusIn( HWND hWnd
, XFocusChangeEvent
*event
);
102 static void EVENT_FocusOut( HWND hWnd
, XFocusChangeEvent
*event
);
103 static void EVENT_Expose( HWND hWnd
, XExposeEvent
*event
);
104 static void EVENT_GraphicsExpose( HWND hWnd
, XGraphicsExposeEvent
*event
);
105 static void EVENT_ConfigureNotify( HWND hWnd
, XConfigureEvent
*event
);
106 static void EVENT_SelectionRequest( HWND hWnd
, XSelectionRequestEvent
*event
, BOOL bIsMultiple
);
107 static void EVENT_SelectionClear( HWND hWnd
, XSelectionClearEvent
*event
);
108 static void EVENT_PropertyNotify( XPropertyEvent
*event
);
109 static void EVENT_ClientMessage( HWND hWnd
, XClientMessageEvent
*event
);
110 static void EVENT_MapNotify( HWND pWnd
, XMapEvent
*event
);
111 static void EVENT_UnmapNotify( HWND pWnd
, XUnmapEvent
*event
);
112 static void EVENT_MappingNotify( XMappingEvent
*event
);
115 static void EVENT_ShmCompletion( XShmCompletionEvent
*event
);
116 static int ShmAvailable
, ShmCompletionType
;
117 extern int XShmGetEventBase( Display
* );/* Missing prototype for function in libXext. */
120 #ifdef HAVE_LIBXXF86DGA2
121 static int DGAMotionEventType
;
122 static int DGAButtonPressEventType
;
123 static int DGAButtonReleaseEventType
;
124 static int DGAKeyPressEventType
;
125 static int DGAKeyReleaseEventType
;
127 static BOOL DGAUsed
= FALSE
;
128 static HWND DGAhwnd
= 0;
130 static void EVENT_DGAMotionEvent( XDGAMotionEvent
*event
);
131 static void EVENT_DGAButtonPressEvent( XDGAButtonEvent
*event
);
132 static void EVENT_DGAButtonReleaseEvent( XDGAButtonEvent
*event
);
135 /* Usable only with OLVWM - compile option perhaps?
136 static void EVENT_EnterNotify( HWND hWnd, XCrossingEvent *event );
139 static void EVENT_GetGeometry( Window win
, int *px
, int *py
,
140 unsigned int *pwidth
, unsigned int *pheight
);
143 static BOOL bUserRepaintDisabled
= TRUE
;
145 /* Static used for the current input method */
146 static INPUT_TYPE current_input_type
= X11DRV_INPUT_ABSOLUTE
;
147 static BOOL in_transition
= FALSE
; /* This is not used as for today */
149 /***********************************************************************
152 BOOL
X11DRV_EVENT_Init(void)
155 ShmAvailable
= XShmQueryExtension( display
);
157 ShmCompletionType
= XShmGetEventBase( display
) + ShmCompletion
;
161 /* Install the X event processing callback */
162 SERVICE_AddObject( FILE_DupUnixHandle( ConnectionNumber(display
),
163 GENERIC_READ
| SYNCHRONIZE
),
164 EVENT_ProcessAllEvents
, 0 );
166 /* Install the XFlush timer callback */
167 if ( Options
.synchronous
)
168 TSXSynchronize( display
, True
);
170 SERVICE_AddTimer( 200000L, EVENT_Flush
, 0 );
175 /***********************************************************************
178 static void CALLBACK
EVENT_Flush( ULONG_PTR arg
)
183 /***********************************************************************
184 * EVENT_ProcessAllEvents
186 static void CALLBACK
EVENT_ProcessAllEvents( ULONG_PTR arg
)
190 TRACE( "called (thread %lx).\n", GetCurrentThreadId() );
192 EnterCriticalSection( &X11DRV_CritSection
);
193 while ( XPending( display
) )
195 XNextEvent( display
, &event
);
197 LeaveCriticalSection( &X11DRV_CritSection
);
198 EVENT_ProcessEvent( &event
);
199 EnterCriticalSection( &X11DRV_CritSection
);
201 LeaveCriticalSection( &X11DRV_CritSection
);
204 /***********************************************************************
207 * Synchronize with the X server. Should not be used too often.
209 void X11DRV_EVENT_Synchronize( void )
211 TSXSync( display
, False
);
212 EVENT_ProcessAllEvents( 0 );
215 /***********************************************************************
216 * EVENT_UserRepaintDisable
218 void X11DRV_EVENT_UserRepaintDisable( BOOL bDisabled
)
220 bUserRepaintDisabled
= bDisabled
;
223 /***********************************************************************
226 * Process an X event.
228 static void EVENT_ProcessEvent( XEvent
*event
)
232 TRACE( "called.\n" );
236 case SelectionNotify
: /* all of these should be caught by XCheckTypedWindowEvent() */
237 FIXME("Got SelectionNotify - must not happen!\n");
240 /* We get all these because of StructureNotifyMask.
241 This check is placed here to avoid getting error messages below,
242 as X might send some of these even for windows that have already
244 case CirculateNotify
:
253 if (ShmAvailable
&& (event
->type
== ShmCompletionType
)) {
254 EVENT_ShmCompletion( (XShmCompletionEvent
*)event
);
259 #ifdef HAVE_LIBXXF86DGA2
261 if (event
->type
== DGAMotionEventType
) {
262 TRACE("DGAMotionEvent received.\n");
263 EVENT_DGAMotionEvent((XDGAMotionEvent
*) event
);
266 if (event
->type
== DGAButtonPressEventType
) {
267 TRACE("DGAButtonPressEvent received.\n");
268 EVENT_DGAButtonPressEvent((XDGAButtonEvent
*) event
);
271 if (event
->type
== DGAButtonReleaseEventType
) {
272 TRACE("DGAButtonReleaseEvent received.\n");
273 EVENT_DGAButtonReleaseEvent((XDGAButtonEvent
*) event
);
276 if ((event
->type
== DGAKeyPressEventType
) ||
277 (event
->type
== DGAKeyReleaseEventType
)) {
278 /* Fill a XKeyEvent to send to EVENT_Key */
280 XDGAKeyEvent
*evt
= (XDGAKeyEvent
*) event
;
282 TRACE("DGAKeyPress/ReleaseEvent received.\n");
284 if (evt
->type
== DGAKeyReleaseEventType
)
285 ke
.type
= KeyRelease
;
288 ke
.serial
= evt
->serial
;
289 ke
.send_event
= FALSE
;
290 ke
.display
= evt
->display
;
299 ke
.state
= evt
->state
;
300 ke
.keycode
= evt
->keycode
;
301 ke
.same_screen
= TRUE
;
303 X11DRV_KEYBOARD_HandleEvent(NULL
, &ke
);
309 if ( TSXFindContext( display
, event
->xany
.window
, winContext
,
310 (char **)&hWnd
) != 0) {
311 if ( event
->type
== ClientMessage
) {
312 /* query window (drag&drop event contains only drag window) */
314 int root_x
, root_y
, child_x
, child_y
;
316 TSXQueryPointer( display
, X11DRV_GetXRootWindow(), &root
, &child
,
317 &root_x
, &root_y
, &child_x
, &child_y
, &u
);
318 if (TSXFindContext( display
, child
, winContext
, (char **)&hWnd
) != 0)
321 hWnd
= 0; /* Not for a registered window */
325 if ( !hWnd
&& event
->xany
.window
!= X11DRV_GetXRootWindow()
326 && event
->type
!= PropertyNotify
327 && event
->type
!= MappingNotify
)
328 ERR("Got event %s for unknown Window %08lx\n",
329 event_names
[event
->type
], event
->xany
.window
);
331 TRACE("Got event %s for hwnd %04x\n",
332 event_names
[event
->type
], hWnd
);
338 EVENT_Key( hWnd
, (XKeyEvent
*)event
);
342 EVENT_ButtonPress( hWnd
, (XButtonEvent
*)event
);
346 EVENT_ButtonRelease( hWnd
, (XButtonEvent
*)event
);
350 /* Wine between two fast machines across the overloaded campus
351 ethernet gets very boged down in MotionEvents. The following
352 simply finds the last motion event in the queue and drops
353 the rest. On a good link events are servered before they build
354 up so this doesn't take place. On a slow link this may cause
355 problems if the event order is important. I'm not yet seen
356 of any problems. Jon 7/6/96.
358 if ((current_input_type
== X11DRV_INPUT_ABSOLUTE
) &&
359 (in_transition
== FALSE
))
360 /* Only cumulate events if in absolute mode */
361 while (TSXCheckTypedWindowEvent(display
,((XAnyEvent
*)event
)->window
,
362 MotionNotify
, event
));
363 EVENT_MotionNotify( hWnd
, (XMotionEvent
*)event
);
368 WND
*pWndLastFocus
= 0;
369 XWindowAttributes win_attr
;
371 XFocusChangeEvent
*xfocChange
= (XFocusChangeEvent
*)event
;
373 if (!hWnd
|| bUserRepaintDisabled
) return;
375 bIsDisabled
= GetWindowLongA( hWnd
, GWL_STYLE
) & WS_DISABLED
;
377 /* If the window has been disabled and we are in managed mode,
378 * revert the X focus back to the last focus window. This is to disallow
379 * the window manager from switching focus away while the app is
382 if ( Options
.managed
&& bIsDisabled
&& glastXFocusWin
)
384 /* Change focus only if saved focus window is registered and viewable */
385 if ( TSXFindContext( xfocChange
->display
, glastXFocusWin
, winContext
,
386 (char **)&pWndLastFocus
) == 0 )
388 if ( TSXGetWindowAttributes( display
, glastXFocusWin
, &win_attr
) &&
389 (win_attr
.map_state
== IsViewable
) )
391 TSXSetInputFocus( xfocChange
->display
, glastXFocusWin
, RevertToParent
, CurrentTime
);
398 EVENT_FocusIn( hWnd
, xfocChange
);
404 /* Save the last window which had the focus */
405 XFocusChangeEvent
*xfocChange
= (XFocusChangeEvent
*)event
;
406 glastXFocusWin
= xfocChange
->window
;
407 if (!hWnd
|| bUserRepaintDisabled
) return;
408 if (GetWindowLongA( hWnd
, GWL_STYLE
) & WS_DISABLED
) glastXFocusWin
= 0;
409 EVENT_FocusOut( hWnd
, (XFocusChangeEvent
*)event
);
414 if (bUserRepaintDisabled
) return;
415 EVENT_Expose( hWnd
, (XExposeEvent
*)event
);
419 if (bUserRepaintDisabled
) return;
420 EVENT_GraphicsExpose( hWnd
, (XGraphicsExposeEvent
*)event
);
423 case ConfigureNotify
:
424 if (!hWnd
|| bUserRepaintDisabled
) return;
425 EVENT_ConfigureNotify( hWnd
, (XConfigureEvent
*)event
);
428 case SelectionRequest
:
429 if (!hWnd
|| bUserRepaintDisabled
) return;
430 EVENT_SelectionRequest( hWnd
, (XSelectionRequestEvent
*)event
, FALSE
);
434 if (!hWnd
|| bUserRepaintDisabled
) return;
435 EVENT_SelectionClear( hWnd
, (XSelectionClearEvent
*) event
);
439 EVENT_PropertyNotify( (XPropertyEvent
*)event
);
443 if (!hWnd
|| bUserRepaintDisabled
) return;
444 EVENT_ClientMessage( hWnd
, (XClientMessageEvent
*) event
);
449 EVENT_EnterNotify( hWnd
, (XCrossingEvent
*) event
);
457 if (!hWnd
|| bUserRepaintDisabled
) return;
458 EVENT_MapNotify( hWnd
, (XMapEvent
*)event
);
462 if (!hWnd
|| bUserRepaintDisabled
) return;
463 EVENT_UnmapNotify( hWnd
, (XUnmapEvent
*)event
);
467 EVENT_MappingNotify( (XMappingEvent
*) event
);
471 WARN("Unprocessed event %s for hwnd %04x\n",
472 event_names
[event
->type
], hWnd
);
475 TRACE( "returns.\n" );
478 /***********************************************************************
481 * Synchronize internal z-order with the window manager's.
483 static BOOL
__check_query_condition( WND
** pWndA
, WND
** pWndB
)
485 /* return TRUE if we have at least two managed windows */
487 for( *pWndB
= NULL
; *pWndA
; *pWndA
= (*pWndA
)->next
)
488 if( (*pWndA
)->flags
& WIN_MANAGED
&&
489 (*pWndA
)->dwStyle
& WS_VISIBLE
) break;
491 for( *pWndB
= (*pWndA
)->next
; *pWndB
; *pWndB
= (*pWndB
)->next
)
492 if( (*pWndB
)->flags
& WIN_MANAGED
&&
493 (*pWndB
)->dwStyle
& WS_VISIBLE
) break;
494 return ((*pWndB
) != NULL
);
497 static Window
__get_common_ancestor( Window A
, Window B
,
498 Window
** children
, unsigned* total
)
500 /* find the real root window */
502 Window root
, *childrenB
;
507 TSXQueryTree( display
, A
, &root
, &A
, children
, total
);
508 TSXQueryTree( display
, B
, &root
, &B
, &childrenB
, &totalB
);
509 if( childrenB
) TSXFree( childrenB
);
510 if( *children
) TSXFree( *children
), *children
= NULL
;
511 } while( A
!= B
&& A
&& B
);
515 TSXQueryTree( display
, A
, &root
, &B
, children
, total
);
521 static Window
__get_top_decoration( Window w
, Window ancestor
)
523 Window
* children
, root
, prev
= w
, parent
= w
;
529 TSXQueryTree( display
, w
, &root
, &parent
, &children
, &total
);
530 if( children
) TSXFree( children
);
531 } while( parent
&& parent
!= ancestor
);
532 TRACE("\t%08x -> %08x\n", (unsigned)prev
, (unsigned)w
);
533 return ( parent
) ? w
: 0 ;
536 static unsigned __td_lookup( Window w
, Window
* list
, unsigned max
)
539 for( i
= max
- 1; i
>= 0; i
-- ) if( list
[i
] == w
) break;
543 static HWND
EVENT_QueryZOrder( HWND hWndCheck
)
545 HWND hwndInsertAfter
= HWND_TOP
;
546 WND
*pWndCheck
= WIN_FindWndPtr(hWndCheck
);
547 WND
*pDesktop
= WIN_GetDesktop();
548 WND
*pWnd
, *pWndZ
= WIN_LockWndPtr(pDesktop
->child
);
549 Window w
, parent
, *children
= NULL
;
550 unsigned total
, check
, pos
, best
;
552 if( !__check_query_condition(&pWndZ
, &pWnd
) )
554 WIN_ReleaseWndPtr(pWndCheck
);
555 WIN_ReleaseWndPtr(pDesktop
->child
);
556 WIN_ReleaseDesktop();
557 return hwndInsertAfter
;
559 WIN_LockWndPtr(pWndZ
);
560 WIN_LockWndPtr(pWnd
);
561 WIN_ReleaseWndPtr(pDesktop
->child
);
562 WIN_ReleaseDesktop();
564 parent
= __get_common_ancestor( X11DRV_WND_GetXWindow(pWndZ
),
565 X11DRV_WND_GetXWindow(pWnd
),
567 if( parent
&& children
)
569 /* w is the ancestor if pWndCheck that is a direct descendant of 'parent' */
571 w
= __get_top_decoration( X11DRV_WND_GetXWindow(pWndCheck
), parent
);
573 if( w
!= children
[total
-1] ) /* check if at the top */
575 /* X child at index 0 is at the bottom, at index total-1 is at the top */
576 check
= __td_lookup( w
, children
, total
);
579 for( WIN_UpdateWndPtr(&pWnd
,pWndZ
); pWnd
;WIN_UpdateWndPtr(&pWnd
,pWnd
->next
))
581 /* go through all windows in Wine z-order... */
583 if( pWnd
!= pWndCheck
)
585 if( !(pWnd
->flags
& WIN_MANAGED
) ||
586 !(w
= __get_top_decoration( X11DRV_WND_GetXWindow(pWnd
), parent
)) )
588 pos
= __td_lookup( w
, children
, total
);
589 if( pos
< best
&& pos
> check
)
591 /* find a nearest Wine window precedes
592 * pWndCheck in the real z-order... */
594 hwndInsertAfter
= pWnd
->hwndSelf
;
596 if( best
- check
== 1 ) break;
601 if( children
) TSXFree( children
);
602 WIN_ReleaseWndPtr(pWnd
);
603 WIN_ReleaseWndPtr(pWndZ
);
604 WIN_ReleaseWndPtr(pWndCheck
);
605 return hwndInsertAfter
;
608 /***********************************************************************
609 * X11DRV_EVENT_XStateToKeyState
611 * Translate a X event state (Button1Mask, ShiftMask, etc...) to
612 * a Windows key state (MK_SHIFT, MK_CONTROL, etc...)
614 WORD
X11DRV_EVENT_XStateToKeyState( int state
)
618 if (state
& Button1Mask
) kstate
|= MK_LBUTTON
;
619 if (state
& Button2Mask
) kstate
|= MK_MBUTTON
;
620 if (state
& Button3Mask
) kstate
|= MK_RBUTTON
;
621 if (state
& ShiftMask
) kstate
|= MK_SHIFT
;
622 if (state
& ControlMask
) kstate
|= MK_CONTROL
;
626 /***********************************************************************
629 static void EVENT_Expose( HWND hWnd
, XExposeEvent
*event
)
633 WND
*pWnd
= WIN_FindWndPtr(hWnd
);
634 /* Make position relative to client area instead of window */
635 rect
.left
= event
->x
- (pWnd
? (pWnd
->rectClient
.left
- pWnd
->rectWindow
.left
) : 0);
636 rect
.top
= event
->y
- (pWnd
? (pWnd
->rectClient
.top
- pWnd
->rectWindow
.top
) : 0);
637 rect
.right
= rect
.left
+ event
->width
;
638 rect
.bottom
= rect
.top
+ event
->height
;
639 WIN_ReleaseWndPtr(pWnd
);
641 Callout
.RedrawWindow( hWnd
, &rect
, 0,
642 RDW_INVALIDATE
| RDW_FRAME
| RDW_ALLCHILDREN
| RDW_ERASE
|
643 (event
->count
? 0 : RDW_ERASENOW
) );
647 /***********************************************************************
648 * EVENT_GraphicsExpose
650 * This is needed when scrolling area is partially obscured
651 * by non-Wine X window.
653 static void EVENT_GraphicsExpose( HWND hWnd
, XGraphicsExposeEvent
*event
)
656 WND
*pWnd
= WIN_FindWndPtr(hWnd
);
658 /* Make position relative to client area instead of window */
659 rect
.left
= event
->x
- (pWnd
? (pWnd
->rectClient
.left
- pWnd
->rectWindow
.left
) : 0);
660 rect
.top
= event
->y
- (pWnd
? (pWnd
->rectClient
.top
- pWnd
->rectWindow
.top
) : 0);
661 rect
.right
= rect
.left
+ event
->width
;
662 rect
.bottom
= rect
.top
+ event
->height
;
664 WIN_ReleaseWndPtr(pWnd
);
666 Callout
.RedrawWindow( hWnd
, &rect
, 0,
667 RDW_INVALIDATE
| RDW_ALLCHILDREN
| RDW_ERASE
|
668 (event
->count
? 0 : RDW_ERASENOW
) );
672 /***********************************************************************
675 * Handle a X key event
677 static void EVENT_Key( HWND hWnd
, XKeyEvent
*event
)
679 WND
*pWnd
= WIN_FindWndPtr(hWnd
);
680 X11DRV_KEYBOARD_HandleEvent( pWnd
, event
);
681 WIN_ReleaseWndPtr(pWnd
);
686 /***********************************************************************
689 static void EVENT_MotionNotify( HWND hWnd
, XMotionEvent
*event
)
691 if (current_input_type
== X11DRV_INPUT_ABSOLUTE
) {
692 WND
*pWnd
= WIN_FindWndPtr(hWnd
);
693 int xOffset
= pWnd
? pWnd
->rectWindow
.left
: 0;
694 int yOffset
= pWnd
? pWnd
->rectWindow
.top
: 0;
695 WIN_ReleaseWndPtr(pWnd
);
697 MOUSE_SendEvent( MOUSEEVENTF_MOVE
| MOUSEEVENTF_ABSOLUTE
,
698 xOffset
+ event
->x
, yOffset
+ event
->y
,
699 X11DRV_EVENT_XStateToKeyState( event
->state
),
700 event
->time
- MSG_WineStartTicks
,
703 MOUSE_SendEvent( MOUSEEVENTF_MOVE
,
704 event
->x_root
, event
->y_root
,
705 X11DRV_EVENT_XStateToKeyState( event
->state
),
706 event
->time
- MSG_WineStartTicks
,
712 /***********************************************************************
715 static void EVENT_ButtonPress( HWND hWnd
, XButtonEvent
*event
)
717 static WORD statusCodes
[NB_BUTTONS
] =
718 { MOUSEEVENTF_LEFTDOWN
, MOUSEEVENTF_MIDDLEDOWN
, MOUSEEVENTF_RIGHTDOWN
, MOUSEEVENTF_WHEEL
, MOUSEEVENTF_WHEEL
};
719 int buttonNum
= event
->button
- 1;
721 WND
*pWnd
= WIN_FindWndPtr(hWnd
);
722 int xOffset
= pWnd
? pWnd
->rectWindow
.left
: 0;
723 int yOffset
= pWnd
? pWnd
->rectWindow
.top
: 0;
724 WORD keystate
,wData
= 0;
726 WIN_ReleaseWndPtr(pWnd
);
728 if (buttonNum
>= NB_BUTTONS
) return;
731 * Get the compatible keystate
733 keystate
= X11DRV_EVENT_XStateToKeyState( event
->state
);
736 * Make sure that the state of the button that was just
742 keystate
|= MK_LBUTTON
;
745 keystate
|= MK_MBUTTON
;
748 keystate
|= MK_RBUTTON
;
754 wData
= -WHEEL_DELTA
;
758 MOUSE_SendEvent( statusCodes
[buttonNum
],
759 xOffset
+ event
->x
, yOffset
+ event
->y
,
760 MAKEWPARAM(keystate
,wData
),
761 event
->time
- MSG_WineStartTicks
,
766 /***********************************************************************
767 * EVENT_ButtonRelease
769 static void EVENT_ButtonRelease( HWND hWnd
, XButtonEvent
*event
)
771 static WORD statusCodes
[NB_BUTTONS
] =
772 { MOUSEEVENTF_LEFTUP
, MOUSEEVENTF_MIDDLEUP
, MOUSEEVENTF_RIGHTUP
};
773 int buttonNum
= event
->button
- 1;
774 WND
*pWnd
= WIN_FindWndPtr(hWnd
);
775 int xOffset
= pWnd
? pWnd
->rectWindow
.left
: 0;
776 int yOffset
= pWnd
? pWnd
->rectWindow
.top
: 0;
779 WIN_ReleaseWndPtr(pWnd
);
781 if (buttonNum
>= NB_BUTTONS
) return;
784 * Get the compatible keystate
786 keystate
= X11DRV_EVENT_XStateToKeyState( event
->state
);
789 * Make sure that the state of the button that was just
795 keystate
&= ~MK_LBUTTON
;
798 keystate
&= ~MK_MBUTTON
;
801 keystate
&= ~MK_RBUTTON
;
807 MOUSE_SendEvent( statusCodes
[buttonNum
],
808 xOffset
+ event
->x
, yOffset
+ event
->y
,
810 event
->time
- MSG_WineStartTicks
,
815 /**********************************************************************
818 static void EVENT_FocusIn( HWND hWnd
, XFocusChangeEvent
*event
)
820 if (event
->detail
!= NotifyPointer
)
821 if (hWnd
!= GetForegroundWindow())
823 SetForegroundWindow( hWnd
);
824 X11DRV_KEYBOARD_UpdateState();
829 /**********************************************************************
832 * Note: only top-level override-redirect windows get FocusOut events.
834 static void EVENT_FocusOut( HWND hWnd
, XFocusChangeEvent
*event
)
836 if (event
->detail
!= NotifyPointer
)
837 if (hWnd
== GetForegroundWindow())
839 SendMessageA( hWnd
, WM_CANCELMODE
, 0, 0 );
841 /* Abey : 6-Oct-99. Check again if the focus out window is the
842 Foreground window, because in most cases the messages sent
843 above must have already changed the foreground window, in which
844 case we don't have to change the foreground window to 0 */
846 if (hWnd
== GetForegroundWindow())
847 SetForegroundWindow( 0 );
851 /**********************************************************************
852 * X11DRV_EVENT_CheckFocus
854 BOOL
X11DRV_EVENT_CheckFocus(void)
860 TSXGetInputFocus(display
, &xW
, &state
);
862 TSXFindContext(display
, xW
, winContext
, (char **)&hWnd
) )
867 /**********************************************************************
870 * Helper function for ConfigureNotify handling.
871 * Get the new geometry of a window relative to the root window.
873 static void EVENT_GetGeometry( Window win
, int *px
, int *py
,
874 unsigned int *pwidth
, unsigned int *pheight
)
877 int x
, y
, width
, height
, border
, depth
;
879 EnterCriticalSection( &X11DRV_CritSection
);
881 /* Get the geometry of the window */
882 XGetGeometry( display
, win
, &root
, &x
, &y
, &width
, &height
,
885 /* Translate the window origin to root coordinates */
886 XTranslateCoordinates( display
, win
, root
, 0, 0, &x
, &y
, &top
);
888 LeaveCriticalSection( &X11DRV_CritSection
);
896 /**********************************************************************
897 * EVENT_ConfigureNotify
899 * The ConfigureNotify event is only selected on top-level windows
900 * when the -managed flag is used.
902 static void EVENT_ConfigureNotify( HWND hWnd
, XConfigureEvent
*event
)
906 unsigned int width
, height
;
907 HWND newInsertAfter
, oldInsertAfter
;
909 /* Get geometry and Z-order according to X */
911 EVENT_GetGeometry( event
->window
, &x
, &y
, &width
, &height
);
912 newInsertAfter
= EVENT_QueryZOrder( hWnd
);
914 /* Get geometry and Z-order according to Wine */
917 * Needs to find the first Visible Window above the current one
919 oldInsertAfter
= hWnd
;
922 oldInsertAfter
= GetWindow( oldInsertAfter
, GW_HWNDPREV
);
925 oldInsertAfter
= HWND_TOP
;
928 if (GetWindowLongA( oldInsertAfter
, GWL_STYLE
) & WS_VISIBLE
) break;
931 /* Compare what has changed */
933 GetWindowRect( hWnd
, &rectWindow
);
934 if ( rectWindow
.left
== x
&& rectWindow
.top
== y
)
937 TRACE_(win
)( "%04x moving from (%d,%d) to (%d,%d)\n", hWnd
,
938 rectWindow
.left
, rectWindow
.top
, x
, y
);
940 if ( rectWindow
.right
- rectWindow
.left
== width
941 && rectWindow
.bottom
- rectWindow
.top
== height
)
944 TRACE_(win
)( "%04x resizing from (%d,%d) to (%d,%d)\n", hWnd
,
945 rectWindow
.right
- rectWindow
.left
,
946 rectWindow
.bottom
- rectWindow
.top
, width
, height
);
948 if ( newInsertAfter
== oldInsertAfter
)
949 flags
|= SWP_NOZORDER
;
951 TRACE_(win
)( "%04x restacking from after %04x to after %04x\n", hWnd
,
952 oldInsertAfter
, newInsertAfter
);
954 /* If anything changed, call SetWindowPos */
956 if ( flags
!= (SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOZORDER
) )
957 SetWindowPos( hWnd
, newInsertAfter
, x
, y
, width
, height
,
958 flags
| SWP_NOACTIVATE
| SWP_WINE_NOHOSTMOVE
);
962 /***********************************************************************
963 * EVENT_SelectionRequest_TARGETS
964 * Service a TARGETS selection request event
966 static Atom
EVENT_SelectionRequest_TARGETS( Window requestor
, Atom target
, Atom rprop
)
968 Atom xaTargets
= TSXInternAtom(display
, "TARGETS", False
);
972 unsigned long cTargets
;
976 TRACE("Request for %s\n", TSXGetAtomName(display
, target
));
979 * Count the number of items we wish to expose as selection targets.
980 * We include the TARGETS item, and a PIXMAP if we have CF_DIB or CF_BITMAP
982 cTargets
= CountClipboardFormats() + 1;
983 if ( CLIPBOARD_IsPresent(CF_DIB
) || CLIPBOARD_IsPresent(CF_BITMAP
) )
986 /* Allocate temp buffer */
987 targets
= (Atom
*)HeapAlloc( GetProcessHeap(), 0, cTargets
* sizeof(Atom
));
988 if(targets
== NULL
) return None
;
990 /* Create TARGETS property list (First item in list is TARGETS itself) */
992 for ( targets
[0] = xaTargets
, cTargets
= 1, wFormat
= 0, bHavePixmap
= FALSE
;
993 (wFormat
= EnumClipboardFormats( wFormat
)); )
995 if ( (prop
= X11DRV_CLIPBOARD_MapFormatToProperty(wFormat
)) != None
)
997 /* Scan through what we have so far to avoid duplicates */
1000 for (i
= 0, bExists
= FALSE
; i
< cTargets
; i
++)
1002 if (targets
[i
] == prop
)
1010 targets
[cTargets
++] = prop
;
1012 /* Add PIXMAP prop for bitmaps additionally */
1013 if ( (wFormat
== CF_DIB
|| wFormat
== CF_BITMAP
)
1016 targets
[cTargets
++] = XA_PIXMAP
;
1023 if (TRACE_ON(event
))
1026 for ( i
= 0; i
< cTargets
; i
++)
1030 char *itemFmtName
= TSXGetAtomName(display
, targets
[i
]);
1031 TRACE("\tAtom# %d: Type %s\n", i
, itemFmtName
);
1032 TSXFree(itemFmtName
);
1037 /* Update the X property */
1038 TRACE("\tUpdating property %s...", TSXGetAtomName(display
, rprop
));
1040 /* We may want to consider setting the type to xaTargets instead,
1041 * in case some apps expect this instead of XA_ATOM */
1042 xRc
= TSXChangeProperty(display
, requestor
, rprop
,
1043 XA_ATOM
, 32, PropModeReplace
,
1044 (unsigned char *)targets
, cTargets
);
1045 TRACE("(Rc=%d)\n", xRc
);
1047 HeapFree( GetProcessHeap(), 0, targets
);
1053 /***********************************************************************
1054 * EVENT_SelectionRequest_STRING
1055 * Service a STRING selection request event
1057 static Atom
EVENT_SelectionRequest_STRING( Window requestor
, Atom target
, Atom rprop
)
1067 * Map the requested X selection property type atom name to a
1068 * windows clipboard format ID.
1070 itemFmtName
= TSXGetAtomName(display
, target
);
1071 TRACE("Request for %s (wFormat=%x %s)\n",
1072 itemFmtName
, CF_TEXT
, CLIPBOARD_GetFormatName(CF_TEXT
));
1073 TSXFree(itemFmtName
);
1075 hText
= GetClipboardData16(CF_TEXT
);
1078 text
= GlobalLock16(hText
);
1081 size
= GlobalSize16(hText
);
1082 /* remove carriage returns */
1084 lpstr
= (char*)HeapAlloc( GetProcessHeap(), 0, size
-- );
1085 if(lpstr
== NULL
) return None
;
1086 for(i
=0,j
=0; i
< size
&& text
[i
]; i
++ )
1088 if( text
[i
] == '\r' &&
1089 (text
[i
+1] == '\n' || text
[i
+1] == '\0') ) continue;
1090 lpstr
[j
++] = text
[i
];
1094 /* Update the X property */
1095 TRACE("\tUpdating property %s...\n", TSXGetAtomName(display
, rprop
));
1096 xRc
= TSXChangeProperty(display
, requestor
, rprop
,
1097 XA_STRING
, 8, PropModeReplace
,
1099 TRACE("(Rc=%d)\n", xRc
);
1101 GlobalUnlock16(hText
);
1102 HeapFree( GetProcessHeap(), 0, lpstr
);
1107 /***********************************************************************
1108 * EVENT_SelectionRequest_PIXMAP
1109 * Service a PIXMAP selection request event
1111 static Atom
EVENT_SelectionRequest_PIXMAP( Window requestor
, Atom target
, Atom rprop
)
1113 HANDLE hClipData
= 0;
1119 XSetWindowAttributes win_attr
;
1120 XWindowAttributes win_attr_src
;
1124 * Map the requested X selection property type atom name to a
1125 * windows clipboard format ID.
1127 itemFmtName
= TSXGetAtomName(display
, target
);
1128 wFormat
= X11DRV_CLIPBOARD_MapPropertyToFormat(itemFmtName
);
1129 TRACE("Request for %s (wFormat=%x %s)\n",
1130 itemFmtName
, wFormat
, CLIPBOARD_GetFormatName( wFormat
));
1131 TSXFree(itemFmtName
);
1133 hClipData
= GetClipboardData(wFormat
);
1136 TRACE("Could not retrieve a Pixmap compatible format from clipboard!\n");
1137 rprop
= None
; /* Fail the request */
1141 if (wFormat
== CF_DIB
)
1143 HWND hwnd
= GetOpenClipboardWindow();
1144 HDC hdc
= GetDC(hwnd
);
1146 /* For convert from packed DIB to Pixmap */
1147 pixmap
= X11DRV_DIB_CreatePixmapFromDIB(hClipData
, hdc
);
1149 ReleaseDC(hdc
, hwnd
);
1151 else if (wFormat
== CF_BITMAP
)
1153 HWND hwnd
= GetOpenClipboardWindow();
1154 HDC hdc
= GetDC(hwnd
);
1156 pixmap
= X11DRV_BITMAP_CreatePixmapFromBitmap(hClipData
, hdc
);
1158 ReleaseDC(hdc
, hwnd
);
1162 FIXME("%s to PIXMAP conversion not yet implemented!\n",
1163 CLIPBOARD_GetFormatName(wFormat
));
1168 TRACE("\tUpdating property %s on Window %ld with %s %ld...\n",
1169 TSXGetAtomName(display
, rprop
), (long)requestor
,
1170 TSXGetAtomName(display
, target
), pixmap
);
1172 /* Store the Pixmap handle in the property */
1173 xRc
= TSXChangeProperty(display
, requestor
, rprop
, target
,
1174 32, PropModeReplace
,
1175 (unsigned char *)&pixmap
, 1);
1176 TRACE("(Rc=%d)\n", xRc
);
1178 /* Enable the code below if you want to handle destroying Pixmap resources
1179 * in response to property notify events. Clients like XPaint don't
1180 * appear to be duplicating Pixmaps so they don't like us deleting,
1181 * the resource in response to the property being deleted.
1184 /* Express interest in property notify events so that we can delete the
1185 * pixmap when the client deletes the property atom.
1187 xRc
= TSXGetWindowAttributes(display
, requestor
, &win_attr_src
);
1188 TRACE("Turning on PropertyChangeEvent notifications from window %ld\n",
1190 win_attr
.event_mask
= win_attr_src
.your_event_mask
| PropertyChangeMask
;
1191 TSXChangeWindowAttributes(display
, requestor
, CWEventMask
, &win_attr
);
1193 /* Register the Pixmap we created with the request property Atom.
1194 * When this property is destroyed we also destroy the Pixmap in
1195 * response to the PropertyNotify event.
1197 X11DRV_CLIPBOARD_RegisterPixmapResource( rprop
, pixmap
);
1205 /***********************************************************************
1206 * EVENT_SelectionRequest_WCF
1207 * Service a Wine Clipboard Format selection request event.
1208 * For <WCF>* data types we simply copy the data to X without conversion.
1210 static Atom
EVENT_SelectionRequest_WCF( Window requestor
, Atom target
, Atom rprop
)
1212 HANDLE hClipData
= 0;
1220 * Map the requested X selection property type atom name to a
1221 * windows clipboard format ID.
1223 itemFmtName
= TSXGetAtomName(display
, target
);
1224 wFormat
= X11DRV_CLIPBOARD_MapPropertyToFormat(itemFmtName
);
1225 TRACE("Request for %s (wFormat=%x %s)\n",
1226 itemFmtName
, wFormat
, CLIPBOARD_GetFormatName( wFormat
));
1227 TSXFree(itemFmtName
);
1229 hClipData
= GetClipboardData16(wFormat
);
1231 if( hClipData
&& (lpClipData
= GlobalLock16(hClipData
)) )
1233 cBytes
= GlobalSize16(hClipData
);
1235 TRACE("\tUpdating property %s, %d bytes...\n",
1236 TSXGetAtomName(display
, rprop
), cBytes
);
1238 xRc
= TSXChangeProperty(display
, requestor
, rprop
,
1239 target
, 8, PropModeReplace
,
1240 (unsigned char *)lpClipData
, cBytes
);
1241 TRACE("(Rc=%d)\n", xRc
);
1243 GlobalUnlock16(hClipData
);
1247 TRACE("\tCould not retrieve native format!\n");
1248 rprop
= None
; /* Fail the request */
1255 /***********************************************************************
1256 * EVENT_SelectionRequest_MULTIPLE
1257 * Service a MULTIPLE selection request event
1258 * rprop contains a list of (target,property) atom pairs.
1259 * The first atom names a target and the second names a property.
1260 * The effect is as if we have received a sequence of SelectionRequest events
1261 * (one for each atom pair) except that:
1262 * 1. We reply with a SelectionNotify only when all the requested conversions
1263 * have been performed.
1264 * 2. If we fail to convert the target named by an atom in the MULTIPLE property,
1265 * we replace the atom in the property by None.
1267 static Atom
EVENT_SelectionRequest_MULTIPLE( HWND hWnd
, XSelectionRequestEvent
*pevent
)
1270 Atom atype
=AnyPropertyType
;
1272 unsigned long remain
;
1273 Atom
* targetPropList
=NULL
;
1274 unsigned long cTargetPropList
= 0;
1275 /* Atom xAtomPair = TSXInternAtom(display, "ATOM_PAIR", False); */
1277 /* If the specified property is None the requestor is an obsolete client.
1278 * We support these by using the specified target atom as the reply property.
1280 rprop
= pevent
->property
;
1282 rprop
= pevent
->target
;
1286 /* Read the MULTIPLE property contents. This should contain a list of
1287 * (target,property) atom pairs.
1289 if(TSXGetWindowProperty(display
, pevent
->requestor
, rprop
,
1290 0, 0x3FFF, False
, AnyPropertyType
, &atype
,&aformat
,
1291 &cTargetPropList
, &remain
,
1292 (unsigned char**)&targetPropList
) != Success
)
1293 TRACE("\tCouldn't read MULTIPLE property\n");
1296 TRACE("\tType %s,Format %d,nItems %ld, Remain %ld\n",
1297 TSXGetAtomName(display
, atype
), aformat
, cTargetPropList
, remain
);
1300 * Make sure we got what we expect.
1301 * NOTE: According to the X-ICCCM Version 2.0 documentation the property sent
1302 * in a MULTIPLE selection request should be of type ATOM_PAIR.
1303 * However some X apps(such as XPaint) are not compliant with this and return
1304 * a user defined atom in atype when XGetWindowProperty is called.
1305 * The data *is* an atom pair but is not denoted as such.
1307 if(aformat
== 32 /* atype == xAtomPair */ )
1311 /* Iterate through the ATOM_PAIR list and execute a SelectionRequest
1312 * for each (target,property) pair */
1314 for (i
= 0; i
< cTargetPropList
; i
+=2)
1316 char *targetName
= TSXGetAtomName(display
, targetPropList
[i
]);
1317 char *propName
= TSXGetAtomName(display
, targetPropList
[i
+1]);
1318 XSelectionRequestEvent event
;
1320 TRACE("MULTIPLE(%d): Target='%s' Prop='%s'\n",
1321 i
/2, targetName
, propName
);
1322 TSXFree(targetName
);
1325 /* We must have a non "None" property to service a MULTIPLE target atom */
1326 if ( !targetPropList
[i
+1] )
1328 TRACE("\tMULTIPLE(%d): Skipping target with empty property!", i
);
1332 /* Set up an XSelectionRequestEvent for this (target,property) pair */
1333 memcpy( &event
, pevent
, sizeof(XSelectionRequestEvent
) );
1334 event
.target
= targetPropList
[i
];
1335 event
.property
= targetPropList
[i
+1];
1337 /* Fire a SelectionRequest, informing the handler that we are processing
1338 * a MULTIPLE selection request event.
1340 EVENT_SelectionRequest( hWnd
, &event
, TRUE
);
1344 /* Free the list of targets/properties */
1345 TSXFree(targetPropList
);
1353 /***********************************************************************
1354 * EVENT_SelectionRequest
1355 * Process an event selection request event.
1356 * The bIsMultiple flag is used to signal when EVENT_SelectionRequest is called
1357 * recursively while servicing a "MULTIPLE" selection target.
1359 * Note: We only receive this event when WINE owns the X selection
1361 static void EVENT_SelectionRequest( HWND hWnd
, XSelectionRequestEvent
*event
, BOOL bIsMultiple
)
1363 XSelectionEvent result
;
1365 Window request
= event
->requestor
;
1366 BOOL couldOpen
= FALSE
;
1367 Atom xaClipboard
= TSXInternAtom(display
, "CLIPBOARD", False
);
1368 Atom xaTargets
= TSXInternAtom(display
, "TARGETS", False
);
1369 Atom xaMultiple
= TSXInternAtom(display
, "MULTIPLE", False
);
1372 * We can only handle the selection request if :
1373 * The selection is PRIMARY or CLIPBOARD, AND we can successfully open the clipboard.
1374 * Don't do these checks or open the clipboard while recursively processing MULTIPLE,
1375 * since this has been already done.
1379 if ( ( (event
->selection
!= XA_PRIMARY
) && (event
->selection
!= xaClipboard
) )
1380 || !(couldOpen
= OpenClipboard(hWnd
)) )
1384 /* If the specified property is None the requestor is an obsolete client.
1385 * We support these by using the specified target atom as the reply property.
1387 rprop
= event
->property
;
1389 rprop
= event
->target
;
1391 if(event
->target
== xaTargets
) /* Return a list of all supported targets */
1393 /* TARGETS selection request */
1394 rprop
= EVENT_SelectionRequest_TARGETS( request
, event
->target
, rprop
);
1396 else if(event
->target
== xaMultiple
) /* rprop contains a list of (target, property) atom pairs */
1398 /* MULTIPLE selection request */
1399 rprop
= EVENT_SelectionRequest_MULTIPLE( hWnd
, event
);
1401 else if(event
->target
== XA_STRING
) /* treat CF_TEXT as Unix text */
1403 /* XA_STRING selection request */
1404 rprop
= EVENT_SelectionRequest_STRING( request
, event
->target
, rprop
);
1406 else if(event
->target
== XA_PIXMAP
) /* Convert DIB's to Pixmaps */
1408 /* XA_PIXMAP selection request */
1409 rprop
= EVENT_SelectionRequest_PIXMAP( request
, event
->target
, rprop
);
1411 else if(event
->target
== XA_BITMAP
) /* Convert DIB's to 1-bit Pixmaps */
1413 /* XA_BITMAP selection request - TODO: create a monochrome Pixmap */
1414 rprop
= EVENT_SelectionRequest_PIXMAP( request
, XA_PIXMAP
, rprop
);
1416 else if(X11DRV_CLIPBOARD_IsNativeProperty(event
->target
)) /* <WCF>* */
1418 /* All <WCF> selection requests */
1419 rprop
= EVENT_SelectionRequest_WCF( request
, event
->target
, rprop
);
1422 rprop
= None
; /* Don't support this format */
1425 /* close clipboard only if we opened before */
1426 if(couldOpen
) CloseClipboard();
1429 TRACE("\tRequest ignored\n");
1432 * SelectionNotify should be sent only at the end of a MULTIPLE request
1436 result
.type
= SelectionNotify
;
1437 result
.display
= display
;
1438 result
.requestor
= request
;
1439 result
.selection
= event
->selection
;
1440 result
.property
= rprop
;
1441 result
.target
= event
->target
;
1442 result
.time
= event
->time
;
1443 TRACE("Sending SelectionNotify event...\n");
1444 TSXSendEvent(display
,event
->requestor
,False
,NoEventMask
,(XEvent
*)&result
);
1448 /***********************************************************************
1449 * EVENT_SelectionClear
1451 static void EVENT_SelectionClear( HWND hWnd
, XSelectionClearEvent
*event
)
1453 Atom xaClipboard
= TSXInternAtom(display
, "CLIPBOARD", False
);
1455 if (event
->selection
== XA_PRIMARY
|| event
->selection
== xaClipboard
)
1456 X11DRV_CLIPBOARD_ReleaseSelection( event
->selection
, event
->window
, hWnd
);
1459 /***********************************************************************
1460 * EVENT_PropertyNotify
1461 * We use this to release resources like Pixmaps when a selection
1462 * client no longer needs them.
1464 static void EVENT_PropertyNotify( XPropertyEvent
*event
)
1466 /* Check if we have any resources to free */
1467 TRACE("Received PropertyNotify event: ");
1469 switch(event
->state
)
1471 case PropertyDelete
:
1473 TRACE("\tPropertyDelete for atom %s on window %ld\n",
1474 TSXGetAtomName(event
->display
, event
->atom
), (long)event
->window
);
1476 if (X11DRV_CLIPBOARD_IsSelectionowner())
1477 X11DRV_CLIPBOARD_FreeResources( event
->atom
);
1481 case PropertyNewValue
:
1483 TRACE("\tPropertyNewValue for atom %s on window %ld\n\n",
1484 TSXGetAtomName(event
->display
, event
->atom
), (long)event
->window
);
1493 /**********************************************************************
1494 * EVENT_DropFromOffix
1496 * don't know if it still works (last Changlog is from 96/11/04)
1498 static void EVENT_DropFromOffiX( HWND hWnd
, XClientMessageEvent
*event
)
1500 unsigned long data_length
;
1501 unsigned long aux_long
;
1502 unsigned char* p_data
= NULL
;
1513 HGLOBAL16 hDragInfo
= GlobalAlloc16( GMEM_SHARE
| GMEM_ZEROINIT
, sizeof(DRAGINFO
));
1514 LPDRAGINFO lpDragInfo
= (LPDRAGINFO
) GlobalLock16(hDragInfo
);
1515 SEGPTR spDragInfo
= (SEGPTR
) WIN16_GlobalLock16(hDragInfo
);
1516 Window w_aux_root
, w_aux_child
;
1520 if( !lpDragInfo
|| !spDragInfo
) return;
1522 pWnd
= WIN_FindWndPtr(hWnd
);
1524 TSXQueryPointer( display
, X11DRV_WND_GetXWindow(pWnd
), &w_aux_root
, &w_aux_child
,
1525 &x
, &y
, (int *) &u
.pt_aux
.x
, (int *) &u
.pt_aux
.y
,
1526 (unsigned int*)&aux_long
);
1528 lpDragInfo
->hScope
= hWnd
;
1529 lpDragInfo
->pt
.x
= (INT16
)x
; lpDragInfo
->pt
.y
= (INT16
)y
;
1531 /* find out drop point and drop window */
1532 if( x
< 0 || y
< 0 ||
1533 x
> (pWnd
->rectWindow
.right
- pWnd
->rectWindow
.left
) ||
1534 y
> (pWnd
->rectWindow
.bottom
- pWnd
->rectWindow
.top
) )
1535 { bAccept
= pWnd
->dwExStyle
& WS_EX_ACCEPTFILES
; x
= y
= 0; }
1538 bAccept
= DRAG_QueryUpdate( hWnd
, spDragInfo
, TRUE
);
1539 x
= lpDragInfo
->pt
.x
; y
= lpDragInfo
->pt
.y
;
1541 pDropWnd
= WIN_FindWndPtr( lpDragInfo
->hScope
);
1542 WIN_ReleaseWndPtr(pWnd
);
1544 GlobalFree16( hDragInfo
);
1548 TSXGetWindowProperty( display
, DefaultRootWindow(display
),
1549 dndSelection
, 0, 65535, FALSE
,
1550 AnyPropertyType
, &u
.atom_aux
, (int *) &u
.pt_aux
.y
,
1551 &data_length
, &aux_long
, &p_data
);
1553 if( !aux_long
&& p_data
) /* don't bother if > 64K */
1555 char *p
= (char*) p_data
;
1559 while( *p
) /* calculate buffer size */
1562 if((u
.i
= *p
) != -1 )
1563 u
.i
= DRIVE_FindDriveRoot( (const char **)&p_drop
);
1564 if( u
.i
== -1 ) *p
= -1; /* mark as "bad" */
1567 INT len
= GetShortPathNameA( p
, NULL
, 0 );
1568 if (len
) aux_long
+= len
+ 1;
1573 if( aux_long
&& aux_long
< 65535 )
1576 LPDROPFILESTRUCT16 lpDrop
;
1578 aux_long
+= sizeof(DROPFILESTRUCT16
) + 1;
1579 hDrop
= (HDROP16
)GlobalAlloc16( GMEM_SHARE
, aux_long
);
1580 lpDrop
= (LPDROPFILESTRUCT16
) GlobalLock16( hDrop
);
1584 lpDrop
->wSize
= sizeof(DROPFILESTRUCT16
);
1585 lpDrop
->ptMousePos
.x
= (INT16
)x
;
1586 lpDrop
->ptMousePos
.y
= (INT16
)y
;
1587 lpDrop
->fInNonClientArea
= (BOOL16
)
1588 ( x
< (pDropWnd
->rectClient
.left
- pDropWnd
->rectWindow
.left
) ||
1589 y
< (pDropWnd
->rectClient
.top
- pDropWnd
->rectWindow
.top
) ||
1590 x
> (pDropWnd
->rectClient
.right
- pDropWnd
->rectWindow
.left
) ||
1591 y
> (pDropWnd
->rectClient
.bottom
- pDropWnd
->rectWindow
.top
) );
1592 p_drop
= ((char*)lpDrop
) + sizeof(DROPFILESTRUCT16
);
1596 if( *p
!= -1 ) /* use only "good" entries */
1598 GetShortPathNameA( p
, p_drop
, 65535 );
1599 p_drop
+= strlen( p_drop
) + 1;
1604 PostMessage16( hWnd
, WM_DROPFILES
,
1605 (WPARAM16
)hDrop
, 0L );
1609 if( p_data
) TSXFree(p_data
);
1611 } /* WS_EX_ACCEPTFILES */
1613 WIN_ReleaseWndPtr(pDropWnd
);
1616 /**********************************************************************
1619 * drop items are separated by \n
1620 * each item is prefixed by its mime type
1622 * event->data.l[3], event->data.l[4] contains drop x,y position
1624 static void EVENT_DropURLs( HWND hWnd
, XClientMessageEvent
*event
)
1628 unsigned long data_length
;
1629 unsigned long aux_long
, drop_len
= 0;
1630 unsigned char *p_data
= NULL
; /* property data */
1631 char *p_drop
= NULL
;
1633 int x
, y
, drop32
= FALSE
;
1644 pWnd
= WIN_FindWndPtr(hWnd
);
1645 drop32
= pWnd
->flags
& WIN_ISWIN32
;
1647 if (!(pWnd
->dwExStyle
& WS_EX_ACCEPTFILES
))
1649 WIN_ReleaseWndPtr(pWnd
);
1652 WIN_ReleaseWndPtr(pWnd
);
1654 TSXGetWindowProperty( display
, DefaultRootWindow(display
),
1655 dndSelection
, 0, 65535, FALSE
,
1656 AnyPropertyType
, &u
.atom_aux
, &u
.i
,
1657 &data_length
, &aux_long
, &p_data
);
1659 WARN("property too large, truncated!\n");
1660 TRACE("urls=%s\n", p_data
);
1662 if( !aux_long
&& p_data
) { /* don't bother if > 64K */
1663 /* calculate length */
1665 next
= strchr(p
, '\n');
1668 if (strncmp(p
,"file:",5) == 0 ) {
1669 INT len
= GetShortPathNameA( p
+5, NULL
, 0 );
1670 if (len
) drop_len
+= len
+ 1;
1675 next
= strchr(p
, '\n');
1681 if( drop_len
&& drop_len
< 65535 ) {
1682 TSXQueryPointer( display
, X11DRV_GetXRootWindow(), &u
.w_aux
, &u
.w_aux
,
1683 &x
, &y
, &u
.i
, &u
.i
, &u
.i
);
1685 pDropWnd
= WIN_FindWndPtr( hWnd
);
1688 LPDROPFILESTRUCT lpDrop
;
1689 drop_len
+= sizeof(DROPFILESTRUCT
) + 1;
1690 hDrop
.h32
= (HDROP
)GlobalAlloc( GMEM_SHARE
, drop_len
);
1691 lpDrop
= (LPDROPFILESTRUCT
) GlobalLock( hDrop
.h32
);
1694 lpDrop
->lSize
= sizeof(DROPFILESTRUCT
);
1695 lpDrop
->ptMousePos
.x
= (INT
)x
;
1696 lpDrop
->ptMousePos
.y
= (INT
)y
;
1697 lpDrop
->fInNonClientArea
= (BOOL
)
1698 ( x
< (pDropWnd
->rectClient
.left
- pDropWnd
->rectWindow
.left
) ||
1699 y
< (pDropWnd
->rectClient
.top
- pDropWnd
->rectWindow
.top
) ||
1700 x
> (pDropWnd
->rectClient
.right
- pDropWnd
->rectWindow
.left
) ||
1701 y
> (pDropWnd
->rectClient
.bottom
- pDropWnd
->rectWindow
.top
) );
1702 lpDrop
->fWideChar
= FALSE
;
1703 p_drop
= ((char*)lpDrop
) + sizeof(DROPFILESTRUCT
);
1706 LPDROPFILESTRUCT16 lpDrop
;
1707 drop_len
+= sizeof(DROPFILESTRUCT16
) + 1;
1708 hDrop
.h16
= (HDROP16
)GlobalAlloc16( GMEM_SHARE
, drop_len
);
1709 lpDrop
= (LPDROPFILESTRUCT16
) GlobalLock16( hDrop
.h16
);
1712 lpDrop
->wSize
= sizeof(DROPFILESTRUCT16
);
1713 lpDrop
->ptMousePos
.x
= (INT16
)x
;
1714 lpDrop
->ptMousePos
.y
= (INT16
)y
;
1715 lpDrop
->fInNonClientArea
= (BOOL16
)
1716 ( x
< (pDropWnd
->rectClient
.left
- pDropWnd
->rectWindow
.left
) ||
1717 y
< (pDropWnd
->rectClient
.top
- pDropWnd
->rectWindow
.top
) ||
1718 x
> (pDropWnd
->rectClient
.right
- pDropWnd
->rectWindow
.left
) ||
1719 y
> (pDropWnd
->rectClient
.bottom
- pDropWnd
->rectWindow
.top
) );
1720 p_drop
= ((char*)lpDrop
) + sizeof(DROPFILESTRUCT16
);
1724 /* create message content */
1727 next
= strchr(p
, '\n');
1730 if (strncmp(p
,"file:",5) == 0 ) {
1731 INT len
= GetShortPathNameA( p
+5, p_drop
, 65535 );
1733 TRACE("drop file %s as %s\n", p
+5, p_drop
);
1736 WARN("can't convert file %s to dos name \n", p
+5);
1739 WARN("unknown mime type %s\n", p
);
1744 next
= strchr(p
, '\n');
1752 /* can not use PostMessage32A because it is currently based on
1753 * PostMessage16 and WPARAM32 would be truncated to WPARAM16
1755 GlobalUnlock(hDrop
.h32
);
1756 SendMessageA( hWnd
, WM_DROPFILES
,
1757 (WPARAM
)hDrop
.h32
, 0L );
1759 GlobalUnlock16(hDrop
.h16
);
1760 PostMessage16( hWnd
, WM_DROPFILES
,
1761 (WPARAM16
)hDrop
.h16
, 0L );
1764 WIN_ReleaseWndPtr(pDropWnd
);
1766 if( p_data
) TSXFree(p_data
);
1770 /**********************************************************************
1771 * EVENT_ClientMessage
1773 static void EVENT_ClientMessage( HWND hWnd
, XClientMessageEvent
*event
)
1775 if (event
->message_type
!= None
&& event
->format
== 32) {
1776 if ((event
->message_type
== wmProtocols
) &&
1777 (((Atom
) event
->data
.l
[0]) == wmDeleteWindow
))
1779 /* Ignore the delete window request if the window has been disabled
1780 * and we are in managed mode. This is to disallow applications from
1781 * being closed by the window manager while in a modal state.
1784 bIsDisabled
= GetWindowLongA( hWnd
, GWL_STYLE
) & WS_DISABLED
;
1786 if ( !Options
.managed
|| !bIsDisabled
)
1787 PostMessage16( hWnd
, WM_SYSCOMMAND
, SC_CLOSE
, 0 );
1789 else if ( event
->message_type
== dndProtocol
&&
1790 (event
->data
.l
[0] == DndFile
|| event
->data
.l
[0] == DndFiles
) )
1791 EVENT_DropFromOffiX(hWnd
, event
);
1792 else if ( event
->message_type
== dndProtocol
&&
1793 event
->data
.l
[0] == DndURL
)
1794 EVENT_DropURLs(hWnd
, event
);
1797 /* enable this if you want to see the message */
1798 unsigned char* p_data
= NULL
;
1804 TSXGetWindowProperty( display
, DefaultRootWindow(display
),
1805 dndSelection
, 0, 65535, FALSE
,
1806 AnyPropertyType
, &u
.atom
, &u
.i
,
1807 &u
.l
, &u
.l
, &p_data
);
1808 TRACE("message_type=%ld, data=%ld,%ld,%ld,%ld,%ld, msg=%s\n",
1809 event
->message_type
, event
->data
.l
[0], event
->data
.l
[1],
1810 event
->data
.l
[2], event
->data
.l
[3], event
->data
.l
[4],
1813 TRACE("unrecognized ClientMessage\n" );
1818 /**********************************************************************
1821 * Install colormap when Wine window is focused in
1822 * self-managed mode with private colormap
1825 void EVENT_EnterNotify( HWND hWnd
, XCrossingEvent
*event
)
1827 if( !Options
.managed
&& X11DRV_GetXRootWindow() == DefaultRootWindow(display
) &&
1828 (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE
) && GetFocus() )
1829 TSXInstallColormap( display
, X11DRV_PALETTE_GetColormap() );
1833 /**********************************************************************
1836 void EVENT_MapNotify( HWND hWnd
, XMapEvent
*event
)
1838 HWND hwndFocus
= GetFocus();
1839 WND
*wndFocus
= WIN_FindWndPtr(hwndFocus
);
1840 WND
*pWnd
= WIN_FindWndPtr(hWnd
);
1841 if (pWnd
->flags
& WIN_MANAGED
)
1843 DCE_InvalidateDCE( pWnd
, &pWnd
->rectWindow
);
1844 pWnd
->dwStyle
&= ~WS_MINIMIZE
;
1845 pWnd
->dwStyle
|= WS_VISIBLE
;
1846 ShowOwnedPopups(hWnd
,TRUE
);
1848 WIN_ReleaseWndPtr(pWnd
);
1850 if (hwndFocus
&& IsChild( hWnd
, hwndFocus
))
1851 X11DRV_WND_SetFocus(wndFocus
);
1853 WIN_ReleaseWndPtr(wndFocus
);
1859 /**********************************************************************
1862 void EVENT_UnmapNotify( HWND hWnd
, XUnmapEvent
*event
)
1864 WND
*pWnd
= WIN_FindWndPtr(hWnd
);
1865 if (pWnd
->flags
& WIN_MANAGED
)
1868 if( pWnd
->dwStyle
& WS_VISIBLE
)
1870 pWnd
->dwStyle
|= WS_MINIMIZE
;
1871 pWnd
->dwStyle
&= ~WS_VISIBLE
;
1872 ShowOwnedPopups(hWnd
,FALSE
);
1875 WIN_ReleaseWndPtr(pWnd
);
1878 /***********************************************************************
1879 * EVENT_MappingNotify
1881 static void EVENT_MappingNotify( XMappingEvent
*event
)
1883 TSXRefreshKeyboardMapping(event
);
1885 /* reinitialize Wine-X11 driver keyboard table */
1886 X11DRV_KEYBOARD_Init();
1890 /**********************************************************************
1891 * X11DRV_EVENT_SetInputMethod
1893 INPUT_TYPE
X11DRV_EVENT_SetInputMethod(INPUT_TYPE type
)
1895 INPUT_TYPE prev
= current_input_type
;
1897 /* Flag not used yet */
1898 in_transition
= FALSE
;
1899 current_input_type
= type
;
1904 #ifdef HAVE_LIBXXF86DGA2
1905 /**********************************************************************
1906 * X11DRV_EVENT_SetDGAStatus
1908 void X11DRV_EVENT_SetDGAStatus(HWND hwnd
, int event_base
)
1910 if (event_base
< 0) {
1916 DGAMotionEventType
= event_base
+ MotionNotify
;
1917 DGAButtonPressEventType
= event_base
+ ButtonPress
;
1918 DGAButtonReleaseEventType
= event_base
+ ButtonRelease
;
1919 DGAKeyPressEventType
= event_base
+ KeyPress
;
1920 DGAKeyReleaseEventType
= event_base
+ KeyRelease
;
1924 /* DGA2 event handlers */
1925 static void EVENT_DGAMotionEvent( XDGAMotionEvent
*event
)
1927 MOUSE_SendEvent( MOUSEEVENTF_MOVE
,
1928 event
->dx
, event
->dy
,
1929 X11DRV_EVENT_XStateToKeyState( event
->state
),
1930 event
->time
- MSG_WineStartTicks
,
1934 static void EVENT_DGAButtonPressEvent( XDGAButtonEvent
*event
)
1936 static WORD statusCodes
[NB_BUTTONS
] =
1937 { MOUSEEVENTF_LEFTDOWN
, MOUSEEVENTF_MIDDLEDOWN
, MOUSEEVENTF_RIGHTDOWN
};
1938 int buttonNum
= event
->button
- 1;
1942 if (buttonNum
>= NB_BUTTONS
) return;
1944 keystate
= X11DRV_EVENT_XStateToKeyState( event
->state
);
1949 keystate
|= MK_LBUTTON
;
1952 keystate
|= MK_MBUTTON
;
1955 keystate
|= MK_RBUTTON
;
1959 MOUSE_SendEvent( statusCodes
[buttonNum
],
1962 event
->time
- MSG_WineStartTicks
,
1966 static void EVENT_DGAButtonReleaseEvent( XDGAButtonEvent
*event
)
1968 static WORD statusCodes
[NB_BUTTONS
] =
1969 { MOUSEEVENTF_LEFTUP
, MOUSEEVENTF_MIDDLEUP
, MOUSEEVENTF_RIGHTUP
};
1970 int buttonNum
= event
->button
- 1;
1974 if (buttonNum
>= NB_BUTTONS
) return;
1976 keystate
= X11DRV_EVENT_XStateToKeyState( event
->state
);
1981 keystate
&= ~MK_LBUTTON
;
1984 keystate
&= ~MK_MBUTTON
;
1987 keystate
&= ~MK_RBUTTON
;
1991 MOUSE_SendEvent( statusCodes
[buttonNum
],
1994 event
->time
- MSG_WineStartTicks
,
2000 #ifdef HAVE_LIBXXSHM
2003 Normal XShm operation:
2005 X11 service thread app thread
2006 ------------- ----------------- ------------------------
2007 (idle) ddraw calls XShmPutImage
2008 (copies data) (waiting for shm_event)
2009 ShmCompletion -> (waiting for shm_event)
2010 (idle) signal shm_event ->
2011 (idle) returns to app
2013 However, this situation can occur for some reason:
2015 X11 service thread app thread
2016 ------------- ----------------- ------------------------
2019 (waiting for app) ddraw calls XShmPutImage
2020 (copies data) (waiting for app) (waiting for shm_event)
2021 ShmCompletion (waiting for app) (waiting for shm_event)
2022 (idle) DEADLOCK DEADLOCK
2024 which is why I also wait for shm_read and do XCheckTypedEvent()
2025 calls in the wait loop. This results in:
2027 X11 service thread app thread
2028 ------------- ----------------- ------------------------
2029 ShmCompletion (waiting for app) waking up on shm_read
2030 (idle) (waiting for app) XCheckTypedEvent() -> signal shm_event
2031 (waiting for app) returns
2041 /* FIXME: this is not pretty */
2042 static HANDLE shm_read
= 0;
2045 static volatile shm_qs shm_q
[SHM_MAX_Q
];
2047 static void EVENT_ShmCompletion( XShmCompletionEvent
*event
)
2051 TRACE("Got ShmCompletion for drawable %ld (time %ld)\n", event
->drawable
, GetTickCount() );
2053 for (n
=0; n
<SHM_MAX_Q
; n
++)
2054 if ((shm_q
[n
].draw
== event
->drawable
) && (shm_q
[n
].state
== 0)) {
2055 HANDLE sema
= shm_q
[n
].sema
;
2056 if (!InterlockedCompareExchange((PVOID
*)&shm_q
[n
].state
, (PVOID
)1, (PVOID
)0)) {
2057 ReleaseSemaphore(sema
, 1, NULL
);
2058 TRACE("Signaling ShmCompletion (#%d) (semaphore %x)\n", n
, sema
);
2063 ERR("Got ShmCompletion for unknown drawable %ld\n", event
->drawable
);
2066 int X11DRV_EVENT_PrepareShmCompletion( Drawable dw
)
2071 shm_read
= FILE_DupUnixHandle( ConnectionNumber(display
), GENERIC_READ
| SYNCHRONIZE
);
2073 for (n
=0; n
<SHM_MAX_Q
; n
++)
2075 if (!InterlockedCompareExchange((PVOID
*)&shm_q
[n
].draw
, (PVOID
)dw
, (PVOID
)0))
2079 ERR("Maximum number of outstanding ShmCompletions exceeded!\n");
2084 if (!shm_q
[n
].sema
) {
2085 shm_q
[n
].sema
= CreateSemaphoreA( NULL
, 0, 256, NULL
);
2086 TRACE("Allocated ShmCompletion slots have been increased to %d, new semaphore is %x\n", n
+1, shm_q
[n
].sema
);
2089 TRACE("Prepared ShmCompletion (#%d) wait for drawable %ld (thread %lx) (time %ld)\n", n
, dw
, GetCurrentThreadId(), GetTickCount() );
2093 static void X11DRV_EVENT_WaitReplaceShmCompletionInternal( int *compl, Drawable dw
, int creat
)
2099 if ((!n
) || (creat
&& (!shm_q
[n
-1].draw
))) {
2100 nn
= X11DRV_EVENT_PrepareShmCompletion(dw
);
2101 if (!(n
=(LONG
)InterlockedCompareExchange((PVOID
*)compl, (PVOID
)nn
, (PVOID
)n
)))
2103 /* race for compl lost, clear slot */
2104 shm_q
[nn
-1].draw
= 0;
2108 if (dw
&& (shm_q
[n
-1].draw
!= dw
)) {
2109 /* this shouldn't happen with the current ddraw implementation */
2110 FIXME("ShmCompletion replace with different drawable!\n");
2114 sema
= shm_q
[n
-1].sema
;
2116 /* nothing to wait on (PrepareShmCompletion not done yet?), so probably nothing to wait for */
2120 nn
= InterlockedExchangeAdd((PLONG
)&shm_q
[n
-1].waiter
, 1);
2121 if ((!shm_q
[n
-1].draw
) || (shm_q
[n
-1].state
== 2)) {
2122 /* too late, the wait was just cleared (wait complete) */
2123 TRACE("Wait skip for ShmCompletion (#%d) (thread %lx) (time %ld) (semaphore %x)\n", n
-1, GetCurrentThreadId(), GetTickCount(), sema
);
2125 TRACE("Waiting for ShmCompletion (#%d) (thread %lx) (time %ld) (semaphore %x)\n", n
-1, GetCurrentThreadId(), GetTickCount(), sema
);
2127 /* another thread is already waiting, let the primary waiter do the dirty work
2128 * (to avoid TSX critical section contention - that could get really slow) */
2129 WaitForSingleObject( sema
, INFINITE
);
2131 /* we're primary waiter - first check if it's already triggered */
2132 if ( WaitForSingleObject( sema
, 0 ) != WAIT_OBJECT_0
) {
2133 /* nope, may need to poll X event queue, in case the service thread is blocked */
2140 /* check X event queue */
2141 if (TSXCheckTypedEvent( display
, ShmCompletionType
, &event
)) {
2142 EVENT_ProcessEvent( &event
);
2144 } while ( WaitForMultipleObjects(2, hnd
, FALSE
, INFINITE
) > WAIT_OBJECT_0
);
2146 TRACE("Wait complete (thread %lx) (time %ld)\n", GetCurrentThreadId(), GetTickCount() );
2149 st
= InterlockedExchange((LPLONG
)&shm_q
[n
-1].state
, 2);
2151 /* first waiter to return, release all other waiters */
2152 nn
= shm_q
[n
-1].waiter
;
2153 TRACE("Signaling %ld additional ShmCompletion (#%d) waiter(s), semaphore %x\n", nn
-1, n
-1, sema
);
2154 ReleaseSemaphore(sema
, nn
-1, NULL
);
2157 nn
= InterlockedDecrement((LPLONG
)&shm_q
[n
-1].waiter
);
2159 /* last waiter to return, replace drawable and prepare new wait */
2160 shm_q
[n
-1].draw
= dw
;
2161 shm_q
[n
-1].state
= 0;
2165 void X11DRV_EVENT_WaitReplaceShmCompletion( int *compl, Drawable dw
)
2167 X11DRV_EVENT_WaitReplaceShmCompletionInternal( compl, dw
, 1 );
2170 void X11DRV_EVENT_WaitShmCompletion( int compl )
2173 X11DRV_EVENT_WaitReplaceShmCompletionInternal( &compl, 0, 0 );
2176 void X11DRV_EVENT_WaitShmCompletions( Drawable dw
)
2180 for (n
=0; n
<SHM_MAX_Q
; n
++)
2181 if (shm_q
[n
].draw
== dw
)
2182 X11DRV_EVENT_WaitShmCompletion( n
+1 );
2185 #endif /* defined(HAVE_LIBXXSHM) */