windows/x11drv/event.c

   1 /*
   2  * X11 event driver
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1999 Noel Borthwick
   6  */
   7
   8 #include "config.h"
   9
  10 #include <X11/Xatom.h>
  11 #include <X11/keysym.h>
  12
  13 #include "ts_xlib.h"
  14 #include "ts_xresource.h"
  15 #include "ts_xutil.h"
  16 #ifdef HAVE_LIBXXSHM
  17 #include "ts_xshm.h"
  18 #endif
  19 #ifdef HAVE_LIBXXF86DGA2
  20 #include "ts_xf86dga2.h"
  21 #endif
  22
  23 #include <assert.h>
  24 #include <string.h>
  25 #include "callback.h"
  26 #include "clipboard.h"
  27 #include "dce.h"
  28 #include "debugtools.h"
  29 #include "drive.h"
  30 #include "heap.h"
  31 #include "input.h"
  32 #include "keyboard.h"
  33 #include "message.h"
  34 #include "mouse.h"
  35 #include "options.h"
  36 #include "queue.h"
  37 #include "shell.h"
  38 #include "win.h"
  39 #include "winpos.h"
  40 #include "services.h"
  41 #include "file.h"
  42 #include "windef.h"
  43 #include "x11drv.h"
  44
  45 DEFAULT_DEBUG_CHANNEL(event);
  46 DECLARE_DEBUG_CHANNEL(win);
  47
  48 /* X context to associate a hwnd to an X window */
  49 extern XContext winContext;
  50
  51 extern Atom wmProtocols;
  52 extern Atom wmDeleteWindow;
  53 extern Atom dndProtocol;
  54 extern Atom dndSelection;
  55
  56 extern void X11DRV_KEYBOARD_UpdateState(void);
  57 extern void X11DRV_KEYBOARD_HandleEvent(WND *pWnd, XKeyEvent *event);
  58
  59 #define NB_BUTTONS      5     /* Windows can handle 3 buttons and the wheel too */
  60
  61
  62 #define DndNotDnd       -1    /* OffiX drag&drop */
  63 #define DndUnknown      0
  64 #define DndRawData      1
  65 #define DndFile         2
  66 #define DndFiles        3
  67 #define DndText         4
  68 #define DndDir          5
  69 #define DndLink         6
  70 #define DndExe          7
  71
  72 #define DndEND          8
  73
  74 #define DndURL          128   /* KDE drag&drop */
  75
  76 /* The last X window which had the focus */
  77 static Window glastXFocusWin = 0;
  78
  79 static const char * const event_names[] =
  80 {
  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"
  89 };
  90
  91
  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 );
  95
  96   /* Event handlers */
  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 );
 113
 114 #ifdef HAVE_LIBXXSHM
 115 static void EVENT_ShmCompletion( XShmCompletionEvent *event );
 116 static int ShmAvailable, ShmCompletionType;
 117 extern int XShmGetEventBase( Display * );/* Missing prototype for function in libXext. */
 118 #endif
 119
 120 #ifdef HAVE_LIBXXF86DGA2
 121 static int DGAMotionEventType;
 122 static int DGAButtonPressEventType;
 123 static int DGAButtonReleaseEventType;
 124 static int DGAKeyPressEventType;
 125 static int DGAKeyReleaseEventType;
 126
 127 static BOOL DGAUsed = FALSE;
 128 static HWND DGAhwnd = 0;
 129
 130 static void EVENT_DGAMotionEvent( XDGAMotionEvent *event );
 131 static void EVENT_DGAButtonPressEvent( XDGAButtonEvent *event );
 132 static void EVENT_DGAButtonReleaseEvent( XDGAButtonEvent *event );
 133 #endif
 134
 135 /* Usable only with OLVWM - compile option perhaps?
 136 static void EVENT_EnterNotify( HWND hWnd, XCrossingEvent *event );
 137 */
 138
 139 static void EVENT_GetGeometry( Window win, int *px, int *py,
 140                                unsigned int *pwidth, unsigned int *pheight );
 141
 142
 143 static BOOL bUserRepaintDisabled = TRUE;
 144
 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 */
 148
 149 /***********************************************************************
 150  *           EVENT_Init
 151  */
 152 BOOL X11DRV_EVENT_Init(void)
 153 {
 154 #ifdef HAVE_LIBXXSHM
 155     ShmAvailable = XShmQueryExtension( display );
 156     if (ShmAvailable) {
 157         ShmCompletionType = XShmGetEventBase( display ) + ShmCompletion;
 158     }
 159 #endif
 160
 161     /* Install the X event processing callback */
 162     SERVICE_AddObject( FILE_DupUnixHandle( ConnectionNumber(display),
 163                                            GENERIC_READ | SYNCHRONIZE ),
 164                        EVENT_ProcessAllEvents, 0 );
 165
 166     /* Install the XFlush timer callback */
 167     if ( Options.synchronous )
 168         TSXSynchronize( display, True );
 169     else
 170         SERVICE_AddTimer( 200000L, EVENT_Flush, 0 );
 171
 172     return TRUE;
 173 }
 174
 175 /***********************************************************************
 176  *           EVENT_Flush
 177  */
 178 static void CALLBACK EVENT_Flush( ULONG_PTR arg )
 179 {
 180     TSXFlush( display );
 181 }
 182
 183 /***********************************************************************
 184  *           EVENT_ProcessAllEvents
 185  */
 186 static void CALLBACK EVENT_ProcessAllEvents( ULONG_PTR arg )
 187 {
 188     XEvent event;
 189
 190     TRACE( "called (thread %lx).\n", GetCurrentThreadId() );
 191
 192     EnterCriticalSection( &X11DRV_CritSection );
 193     while ( XPending( display ) )
 194     {
 195         XNextEvent( display, &event );
 196
 197         LeaveCriticalSection( &X11DRV_CritSection );
 198         EVENT_ProcessEvent( &event );
 199         EnterCriticalSection( &X11DRV_CritSection );
 200     }
 201     LeaveCriticalSection( &X11DRV_CritSection );
 202 }
 203
 204 /***********************************************************************
 205  *           EVENT_Synchronize
 206  *
 207  * Synchronize with the X server. Should not be used too often.
 208  */
 209 void X11DRV_EVENT_Synchronize( void )
 210 {
 211     TSXSync( display, False );
 212     EVENT_ProcessAllEvents( 0 );
 213 }
 214
 215 /***********************************************************************
 216  *           EVENT_UserRepaintDisable
 217  */
 218 void X11DRV_EVENT_UserRepaintDisable( BOOL bDisabled )
 219 {
 220     bUserRepaintDisabled = bDisabled;
 221 }
 222
 223 /***********************************************************************
 224  *           EVENT_ProcessEvent
 225  *
 226  * Process an X event.
 227  */
 228 static void EVENT_ProcessEvent( XEvent *event )
 229 {
 230   HWND hWnd;
 231
 232   TRACE( "called.\n" );
 233
 234   switch (event->type)
 235   {
 236     case SelectionNotify: /* all of these should be caught by XCheckTypedWindowEvent() */
 237          FIXME("Got SelectionNotify - must not happen!\n");
 238          /* fall through */
 239
 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
 243          been deleted ... */
 244     case CirculateNotify:
 245     case CreateNotify:
 246     case DestroyNotify:
 247     case GravityNotify:
 248     case ReparentNotify:
 249       return;
 250   }
 251
 252 #ifdef HAVE_LIBXXSHM
 253   if (ShmAvailable && (event->type == ShmCompletionType)) {
 254     EVENT_ShmCompletion( (XShmCompletionEvent*)event );
 255     return;
 256   }
 257 #endif
 258
 259 #ifdef HAVE_LIBXXF86DGA2
 260   if (DGAUsed) {
 261     if (event->type == DGAMotionEventType) {
 262       TRACE("DGAMotionEvent received.\n");
 263       EVENT_DGAMotionEvent((XDGAMotionEvent *) event);
 264       return;
 265     }
 266     if (event->type == DGAButtonPressEventType) {
 267       TRACE("DGAButtonPressEvent received.\n");
 268       EVENT_DGAButtonPressEvent((XDGAButtonEvent *) event);
 269       return;
 270     }
 271     if (event->type == DGAButtonReleaseEventType) {
 272       TRACE("DGAButtonReleaseEvent received.\n");
 273       EVENT_DGAButtonReleaseEvent((XDGAButtonEvent *) event);
 274       return;
 275     }
 276     if ((event->type == DGAKeyPressEventType) ||
 277         (event->type == DGAKeyReleaseEventType)) {
 278       /* Fill a XKeyEvent to send to EVENT_Key */
 279       XKeyEvent ke;
 280       XDGAKeyEvent *evt = (XDGAKeyEvent *) event;
 281
 282       TRACE("DGAKeyPress/ReleaseEvent received.\n");
 283
 284       if (evt->type == DGAKeyReleaseEventType)
 285         ke.type = KeyRelease;
 286       else
 287         ke.type = KeyPress;
 288       ke.serial = evt->serial;
 289       ke.send_event = FALSE;
 290       ke.display = evt->display;
 291       ke.window = 0;
 292       ke.root = 0;
 293       ke.subwindow = 0;
 294       ke.time = evt->time;
 295       ke.x = PosX;
 296       ke.y = PosY;
 297       ke.x_root = -1;
 298       ke.y_root = -1;
 299       ke.state = evt->state;
 300       ke.keycode = evt->keycode;
 301       ke.same_screen = TRUE;
 302
 303       X11DRV_KEYBOARD_HandleEvent(NULL, &ke);
 304       return;
 305     }
 306   }
 307 #endif
 308
 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) */
 313       Window    root, child;
 314       int       root_x, root_y, child_x, child_y;
 315       unsigned  u;
 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)
 319         return;
 320     } else {
 321       hWnd = 0;  /* Not for a registered window */
 322     }
 323   }
 324
 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 );
 330   else
 331       TRACE("Got event %s for hwnd %04x\n",
 332             event_names[event->type], hWnd );
 333
 334   switch(event->type)
 335     {
 336     case KeyPress:
 337     case KeyRelease:
 338       EVENT_Key( hWnd, (XKeyEvent*)event );
 339       break;
 340
 341     case ButtonPress:
 342       EVENT_ButtonPress( hWnd, (XButtonEvent*)event );
 343       break;
 344
 345     case ButtonRelease:
 346       EVENT_ButtonRelease( hWnd, (XButtonEvent*)event );
 347       break;
 348
 349     case MotionNotify:
 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.
 357       */
 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 );
 364       break;
 365
 366     case FocusIn:
 367     {
 368       WND *pWndLastFocus = 0;
 369       XWindowAttributes win_attr;
 370       BOOL bIsDisabled;
 371       XFocusChangeEvent *xfocChange = (XFocusChangeEvent*)event;
 372
 373       if (!hWnd || bUserRepaintDisabled) return;
 374
 375       bIsDisabled = GetWindowLongA( hWnd, GWL_STYLE ) & WS_DISABLED;
 376
 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
 380        * in a modal state.
 381        */
 382       if ( Options.managed && bIsDisabled && glastXFocusWin)
 383       {
 384         /* Change focus only if saved focus window is registered and viewable */
 385         if ( TSXFindContext( xfocChange->display, glastXFocusWin, winContext,
 386                              (char **)&pWndLastFocus ) == 0 )
 387         {
 388           if ( TSXGetWindowAttributes( display, glastXFocusWin, &win_attr ) &&
 389                  (win_attr.map_state == IsViewable) )
 390           {
 391             TSXSetInputFocus( xfocChange->display, glastXFocusWin, RevertToParent, CurrentTime );
 392             EVENT_Synchronize();
 393       break;
 394           }
 395         }
 396       }
 397
 398       EVENT_FocusIn( hWnd, xfocChange );
 399       break;
 400     }
 401
 402     case FocusOut:
 403     {
 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 );
 410       break;
 411     }
 412
 413     case Expose:
 414       if (bUserRepaintDisabled) return;
 415       EVENT_Expose( hWnd, (XExposeEvent *)event );
 416       break;
 417
 418     case GraphicsExpose:
 419       if (bUserRepaintDisabled) return;
 420       EVENT_GraphicsExpose( hWnd, (XGraphicsExposeEvent *)event );
 421       break;
 422
 423     case ConfigureNotify:
 424       if (!hWnd || bUserRepaintDisabled) return;
 425       EVENT_ConfigureNotify( hWnd, (XConfigureEvent*)event );
 426       break;
 427
 428     case SelectionRequest:
 429       if (!hWnd || bUserRepaintDisabled) return;
 430       EVENT_SelectionRequest( hWnd, (XSelectionRequestEvent *)event, FALSE );
 431       break;
 432
 433     case SelectionClear:
 434       if (!hWnd || bUserRepaintDisabled) return;
 435       EVENT_SelectionClear( hWnd, (XSelectionClearEvent*) event );
 436       break;
 437
 438     case PropertyNotify:
 439       EVENT_PropertyNotify( (XPropertyEvent *)event );
 440       break;
 441
 442     case ClientMessage:
 443       if (!hWnd || bUserRepaintDisabled) return;
 444       EVENT_ClientMessage( hWnd, (XClientMessageEvent *) event );
 445       break;
 446
 447 #if 0
 448     case EnterNotify:
 449       EVENT_EnterNotify( hWnd, (XCrossingEvent *) event );
 450       break;
 451 #endif
 452
 453     case NoExpose:
 454       break;
 455
 456     case MapNotify:
 457       if (!hWnd || bUserRepaintDisabled) return;
 458       EVENT_MapNotify( hWnd, (XMapEvent *)event );
 459       break;
 460
 461     case UnmapNotify:
 462       if (!hWnd || bUserRepaintDisabled) return;
 463       EVENT_UnmapNotify( hWnd, (XUnmapEvent *)event );
 464       break;
 465
 466     case MappingNotify:
 467       EVENT_MappingNotify( (XMappingEvent *) event );
 468       break;
 469
 470     default:
 471       WARN("Unprocessed event %s for hwnd %04x\n",
 472            event_names[event->type], hWnd );
 473       break;
 474     }
 475     TRACE( "returns.\n" );
 476 }
 477
 478 /***********************************************************************
 479  *           EVENT_QueryZOrder
 480  *
 481  * Synchronize internal z-order with the window manager's.
 482  */
 483 static BOOL __check_query_condition( WND** pWndA, WND** pWndB )
 484 {
 485   /* return TRUE if we have at least two managed windows */
 486
 487   for( *pWndB = NULL; *pWndA; *pWndA = (*pWndA)->next )
 488     if( (*pWndA)->flags & WIN_MANAGED &&
 489         (*pWndA)->dwStyle & WS_VISIBLE ) break;
 490   if( *pWndA )
 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);
 495 }
 496
 497 static Window __get_common_ancestor( Window A, Window B,
 498                                      Window** children, unsigned* total )
 499 {
 500     /* find the real root window */
 501
 502     Window      root, *childrenB;
 503     unsigned    totalB;
 504
 505     do
 506     {
 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 );
 512
 513     if( A && B )
 514     {
 515         TSXQueryTree( display, A, &root, &B, children, total );
 516         return A;
 517     }
 518     return 0 ;
 519 }
 520
 521 static Window __get_top_decoration( Window w, Window ancestor )
 522 {
 523   Window*     children, root, prev = w, parent = w;
 524   unsigned    total;
 525
 526   do
 527     {
 528       w = parent;
 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 ;
 534 }
 535
 536 static unsigned __td_lookup( Window w, Window* list, unsigned max )
 537 {
 538   unsigned    i;
 539   for( i = max - 1; i >= 0; i-- ) if( list[i] == w ) break;
 540   return i;
 541 }
 542
 543 static HWND EVENT_QueryZOrder( HWND hWndCheck)
 544 {
 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;
 551
 552   if( !__check_query_condition(&pWndZ, &pWnd) )
 553   {
 554       WIN_ReleaseWndPtr(pWndCheck);
 555       WIN_ReleaseWndPtr(pDesktop->child);
 556       WIN_ReleaseDesktop();
 557       return hwndInsertAfter;
 558   }
 559   WIN_LockWndPtr(pWndZ);
 560   WIN_LockWndPtr(pWnd);
 561   WIN_ReleaseWndPtr(pDesktop->child);
 562   WIN_ReleaseDesktop();
 563
 564   parent = __get_common_ancestor( X11DRV_WND_GetXWindow(pWndZ),
 565                                   X11DRV_WND_GetXWindow(pWnd),
 566                                   &children, &total );
 567   if( parent && children )
 568   {
 569       /* w is the ancestor if pWndCheck that is a direct descendant of 'parent' */
 570
 571       w = __get_top_decoration( X11DRV_WND_GetXWindow(pWndCheck), parent );
 572
 573       if( w != children[total-1] ) /* check if at the top */
 574       {
 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 );
 577           best = total;
 578
 579           for( WIN_UpdateWndPtr(&pWnd,pWndZ); pWnd;WIN_UpdateWndPtr(&pWnd,pWnd->next))
 580           {
 581               /* go through all windows in Wine z-order... */
 582
 583               if( pWnd != pWndCheck )
 584               {
 585                   if( !(pWnd->flags & WIN_MANAGED) ||
 586                       !(w = __get_top_decoration( X11DRV_WND_GetXWindow(pWnd), parent )) )
 587                     continue;
 588                   pos = __td_lookup( w, children, total );
 589                   if( pos < best && pos > check )
 590                   {
 591                       /* find a nearest Wine window precedes
 592                        * pWndCheck in the real z-order... */
 593                       best = pos;
 594                       hwndInsertAfter = pWnd->hwndSelf;
 595                   }
 596                   if( best - check == 1 ) break;
 597               }
 598           }
 599       }
 600   }
 601   if( children ) TSXFree( children );
 602   WIN_ReleaseWndPtr(pWnd);
 603   WIN_ReleaseWndPtr(pWndZ);
 604   WIN_ReleaseWndPtr(pWndCheck);
 605   return hwndInsertAfter;
 606 }
 607
 608 /***********************************************************************
 609  *           X11DRV_EVENT_XStateToKeyState
 610  *
 611  * Translate a X event state (Button1Mask, ShiftMask, etc...) to
 612  * a Windows key state (MK_SHIFT, MK_CONTROL, etc...)
 613  */
 614 WORD X11DRV_EVENT_XStateToKeyState( int state )
 615 {
 616   int kstate = 0;
 617
 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;
 623   return kstate;
 624 }
 625
 626 /***********************************************************************
 627  *           EVENT_Expose
 628  */
 629 static void EVENT_Expose( HWND hWnd, XExposeEvent *event )
 630 {
 631   RECT rect;
 632
 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);
 640
 641   Callout.RedrawWindow( hWnd, &rect, 0,
 642                           RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE |
 643                           (event->count ? 0 : RDW_ERASENOW) );
 644 }
 645
 646
 647 /***********************************************************************
 648  *           EVENT_GraphicsExpose
 649  *
 650  * This is needed when scrolling area is partially obscured
 651  * by non-Wine X window.
 652  */
 653 static void EVENT_GraphicsExpose( HWND hWnd, XGraphicsExposeEvent *event )
 654 {
 655   RECT rect;
 656   WND *pWnd = WIN_FindWndPtr(hWnd);
 657
 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;
 663
 664   WIN_ReleaseWndPtr(pWnd);
 665
 666   Callout.RedrawWindow( hWnd, &rect, 0,
 667                           RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE |
 668                           (event->count ? 0 : RDW_ERASENOW) );
 669 }
 670
 671
 672 /***********************************************************************
 673  *           EVENT_Key
 674  *
 675  * Handle a X key event
 676  */
 677 static void EVENT_Key( HWND hWnd, XKeyEvent *event )
 678 {
 679     WND *pWnd = WIN_FindWndPtr(hWnd);
 680   X11DRV_KEYBOARD_HandleEvent( pWnd, event );
 681     WIN_ReleaseWndPtr(pWnd);
 682
 683 }
 684
 685
 686 /***********************************************************************
 687  *           EVENT_MotionNotify
 688  */
 689 static void EVENT_MotionNotify( HWND hWnd, XMotionEvent *event )
 690 {
 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);
 696
 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,
 701                      hWnd);
 702   } else {
 703     MOUSE_SendEvent( MOUSEEVENTF_MOVE,
 704                      event->x_root, event->y_root,
 705                      X11DRV_EVENT_XStateToKeyState( event->state ),
 706                      event->time - MSG_WineStartTicks,
 707                      hWnd);
 708   }
 709 }
 710
 711
 712 /***********************************************************************
 713  *           EVENT_ButtonPress
 714  */
 715 static void EVENT_ButtonPress( HWND hWnd, XButtonEvent *event )
 716 {
 717   static WORD statusCodes[NB_BUTTONS] =
 718   { MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_RIGHTDOWN, MOUSEEVENTF_WHEEL, MOUSEEVENTF_WHEEL};
 719   int buttonNum = event->button - 1;
 720
 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;
 725
 726   WIN_ReleaseWndPtr(pWnd);
 727
 728   if (buttonNum >= NB_BUTTONS) return;
 729
 730   /*
 731    * Get the compatible keystate
 732    */
 733   keystate = X11DRV_EVENT_XStateToKeyState( event->state );
 734
 735   /*
 736    * Make sure that the state of the button that was just
 737    * pressed is "down".
 738    */
 739   switch (buttonNum)
 740   {
 741     case 0:
 742       keystate |= MK_LBUTTON;
 743       break;
 744     case 1:
 745       keystate |= MK_MBUTTON;
 746       break;
 747     case 2:
 748       keystate |= MK_RBUTTON;
 749       break;
 750     case 3:
 751         wData = WHEEL_DELTA;
 752         break;
 753     case 4:
 754         wData = -WHEEL_DELTA;
 755         break;
 756   }
 757
 758   MOUSE_SendEvent( statusCodes[buttonNum],
 759                    xOffset + event->x, yOffset + event->y,
 760                    MAKEWPARAM(keystate,wData),
 761                    event->time - MSG_WineStartTicks,
 762                    hWnd);
 763 }
 764
 765
 766 /***********************************************************************
 767  *           EVENT_ButtonRelease
 768  */
 769 static void EVENT_ButtonRelease( HWND hWnd, XButtonEvent *event )
 770 {
 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;
 777   WORD keystate;
 778
 779   WIN_ReleaseWndPtr(pWnd);
 780
 781   if (buttonNum >= NB_BUTTONS) return;
 782
 783   /*
 784    * Get the compatible keystate
 785    */
 786   keystate = X11DRV_EVENT_XStateToKeyState( event->state );
 787
 788   /*
 789    * Make sure that the state of the button that was just
 790    * released is "up".
 791    */
 792   switch (buttonNum)
 793   {
 794     case 0:
 795       keystate &= ~MK_LBUTTON;
 796       break;
 797     case 1:
 798       keystate &= ~MK_MBUTTON;
 799       break;
 800     case 2:
 801       keystate &= ~MK_RBUTTON;
 802       break;
 803   default:
 804       return;
 805   }
 806
 807   MOUSE_SendEvent( statusCodes[buttonNum],
 808                    xOffset + event->x, yOffset + event->y,
 809                    keystate,
 810                    event->time - MSG_WineStartTicks,
 811                    hWnd);
 812 }
 813
 814
 815 /**********************************************************************
 816  *              EVENT_FocusIn
 817  */
 818 static void EVENT_FocusIn( HWND hWnd, XFocusChangeEvent *event )
 819 {
 820     if (event->detail != NotifyPointer)
 821         if (hWnd != GetForegroundWindow())
 822         {
 823             SetForegroundWindow( hWnd );
 824             X11DRV_KEYBOARD_UpdateState();
 825         }
 826 }
 827
 828
 829 /**********************************************************************
 830  *              EVENT_FocusOut
 831  *
 832  * Note: only top-level override-redirect windows get FocusOut events.
 833  */
 834 static void EVENT_FocusOut( HWND hWnd, XFocusChangeEvent *event )
 835 {
 836     if (event->detail != NotifyPointer)
 837         if (hWnd == GetForegroundWindow())
 838         {
 839             SendMessageA( hWnd, WM_CANCELMODE, 0, 0 );
 840
 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 */
 845
 846             if (hWnd == GetForegroundWindow())
 847                 SetForegroundWindow( 0 );
 848         }
 849 }
 850
 851 /**********************************************************************
 852  *              X11DRV_EVENT_CheckFocus
 853  */
 854 BOOL X11DRV_EVENT_CheckFocus(void)
 855 {
 856   HWND   hWnd;
 857   Window xW;
 858   int      state;
 859
 860   TSXGetInputFocus(display, &xW, &state);
 861     if( xW == None ||
 862         TSXFindContext(display, xW, winContext, (char **)&hWnd) )
 863       return FALSE;
 864     return TRUE;
 865 }
 866
 867 /**********************************************************************
 868  *              EVENT_GetGeometry
 869  *
 870  * Helper function for ConfigureNotify handling.
 871  * Get the new geometry of a window relative to the root window.
 872  */
 873 static void EVENT_GetGeometry( Window win, int *px, int *py,
 874                                unsigned int *pwidth, unsigned int *pheight )
 875 {
 876     Window root, top;
 877     int x, y, width, height, border, depth;
 878
 879     EnterCriticalSection( &X11DRV_CritSection );
 880
 881     /* Get the geometry of the window */
 882     XGetGeometry( display, win, &root, &x, &y, &width, &height,
 883                   &border, &depth );
 884
 885     /* Translate the window origin to root coordinates */
 886     XTranslateCoordinates( display, win, root, 0, 0, &x, &y, &top );
 887
 888     LeaveCriticalSection( &X11DRV_CritSection );
 889
 890     *px = x;
 891     *py = y;
 892     *pwidth = width;
 893     *pheight = height;
 894 }
 895
 896 /**********************************************************************
 897  *              EVENT_ConfigureNotify
 898  *
 899  * The ConfigureNotify event is only selected on top-level windows
 900  * when the -managed flag is used.
 901  */
 902 static void EVENT_ConfigureNotify( HWND hWnd, XConfigureEvent *event )
 903 {
 904     RECT rectWindow;
 905     int x, y, flags = 0;
 906     unsigned int width, height;
 907     HWND newInsertAfter, oldInsertAfter;
 908
 909     /* Get geometry and Z-order according to X */
 910
 911     EVENT_GetGeometry( event->window, &x, &y, &width, &height );
 912     newInsertAfter = EVENT_QueryZOrder( hWnd );
 913
 914     /* Get geometry and Z-order according to Wine */
 915
 916     /*
 917      *  Needs to find the first Visible Window above the current one
 918      */
 919     oldInsertAfter = hWnd;
 920     for (;;)
 921     {
 922         oldInsertAfter = GetWindow( oldInsertAfter, GW_HWNDPREV );
 923         if (!oldInsertAfter)
 924         {
 925             oldInsertAfter = HWND_TOP;
 926             break;
 927         }
 928         if (GetWindowLongA( oldInsertAfter, GWL_STYLE ) & WS_VISIBLE) break;
 929     }
 930
 931     /* Compare what has changed */
 932
 933     GetWindowRect( hWnd, &rectWindow );
 934     if ( rectWindow.left == x && rectWindow.top == y )
 935         flags |= SWP_NOMOVE;
 936     else
 937         TRACE_(win)( "%04x moving from (%d,%d) to (%d,%d)\n", hWnd,
 938                      rectWindow.left, rectWindow.top, x, y );
 939
 940     if (    rectWindow.right - rectWindow.left == width
 941          && rectWindow.bottom - rectWindow.top == height )
 942         flags |= SWP_NOSIZE;
 943     else
 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 );
 947
 948     if ( newInsertAfter == oldInsertAfter )
 949         flags |= SWP_NOZORDER;
 950     else
 951         TRACE_(win)( "%04x restacking from after %04x to after %04x\n", hWnd,
 952                      oldInsertAfter, newInsertAfter );
 953
 954     /* If anything changed, call SetWindowPos */
 955
 956     if ( flags != (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER) )
 957         SetWindowPos( hWnd, newInsertAfter, x, y, width, height,
 958                             flags | SWP_NOACTIVATE | SWP_WINE_NOHOSTMOVE );
 959 }
 960
 961
 962 /***********************************************************************
 963  *           EVENT_SelectionRequest_TARGETS
 964  *  Service a TARGETS selection request event
 965  */
 966 static Atom EVENT_SelectionRequest_TARGETS( Window requestor, Atom target, Atom rprop )
 967 {
 968     Atom xaTargets = TSXInternAtom(display, "TARGETS", False);
 969     Atom* targets;
 970     Atom prop;
 971     UINT wFormat;
 972     unsigned long cTargets;
 973     BOOL bHavePixmap;
 974     int xRc;
 975
 976     TRACE("Request for %s\n", TSXGetAtomName(display, target));
 977
 978     /*
 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
 981      */
 982     cTargets = CountClipboardFormats() + 1;
 983     if ( CLIPBOARD_IsPresent(CF_DIB) ||  CLIPBOARD_IsPresent(CF_BITMAP) )
 984        cTargets++;
 985
 986     /* Allocate temp buffer */
 987     targets = (Atom*)HeapAlloc( GetProcessHeap(), 0, cTargets * sizeof(Atom));
 988     if(targets == NULL) return None;
 989
 990     /* Create TARGETS property list (First item in list is TARGETS itself) */
 991
 992     for ( targets[0] = xaTargets, cTargets = 1, wFormat = 0, bHavePixmap = FALSE;
 993           (wFormat = EnumClipboardFormats( wFormat )); )
 994     {
 995         if ( (prop = X11DRV_CLIPBOARD_MapFormatToProperty(wFormat)) != None )
 996         {
 997             /* Scan through what we have so far to avoid duplicates */
 998             int i;
 999             BOOL bExists;
1000             for (i = 0, bExists = FALSE; i < cTargets; i++)
1001             {
1002                 if (targets[i] == prop)
1003                 {
1004                     bExists = TRUE;
1005                     break;
1006                 }
1007             }
1008             if (!bExists)
1009             {
1010                 targets[cTargets++] = prop;
1011
1012                 /* Add PIXMAP prop for bitmaps additionally */
1013                 if ( (wFormat == CF_DIB || wFormat == CF_BITMAP )
1014                      && !bHavePixmap )
1015                 {
1016                     targets[cTargets++] = XA_PIXMAP;
1017                     bHavePixmap = TRUE;
1018                 }
1019             }
1020         }
1021     }
1022
1023     if (TRACE_ON(event))
1024     {
1025         int i;
1026         for ( i = 0; i < cTargets; i++)
1027         {
1028             if (targets[i])
1029             {
1030                 char *itemFmtName = TSXGetAtomName(display, targets[i]);
1031                 TRACE("\tAtom# %d:  Type %s\n", i, itemFmtName);
1032                 TSXFree(itemFmtName);
1033             }
1034         }
1035     }
1036
1037     /* Update the X property */
1038     TRACE("\tUpdating property %s...", TSXGetAtomName(display, rprop));
1039
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);
1046
1047     HeapFree( GetProcessHeap(), 0, targets );
1048
1049     return rprop;
1050 }
1051
1052
1053 /***********************************************************************
1054  *           EVENT_SelectionRequest_STRING
1055  *  Service a STRING selection request event
1056  */
1057 static Atom EVENT_SelectionRequest_STRING( Window requestor, Atom target, Atom rprop )
1058 {
1059     HANDLE16 hText;
1060     LPSTR  text;
1061     int    size,i,j;
1062     char* lpstr = 0;
1063     char *itemFmtName;
1064     int xRc;
1065
1066     /*
1067      * Map the requested X selection property type atom name to a
1068      * windows clipboard format ID.
1069      */
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);
1074
1075     hText = GetClipboardData16(CF_TEXT);
1076     if ( !hText )
1077        return None;
1078     text = GlobalLock16(hText);
1079     if (!text)
1080        return None;
1081     size = GlobalSize16(hText);
1082     /* remove carriage returns */
1083
1084     lpstr = (char*)HeapAlloc( GetProcessHeap(), 0, size-- );
1085     if(lpstr == NULL) return None;
1086     for(i=0,j=0; i < size && text[i]; i++ )
1087     {
1088         if( text[i] == '\r' &&
1089             (text[i+1] == '\n' || text[i+1] == '\0') ) continue;
1090         lpstr[j++] = text[i];
1091     }
1092     lpstr[j]='\0';
1093
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,
1098                             lpstr, j);
1099     TRACE("(Rc=%d)\n", xRc);
1100
1101     GlobalUnlock16(hText);
1102     HeapFree( GetProcessHeap(), 0, lpstr );
1103
1104     return rprop;
1105 }
1106
1107 /***********************************************************************
1108  *           EVENT_SelectionRequest_PIXMAP
1109  *  Service a PIXMAP selection request event
1110  */
1111 static Atom EVENT_SelectionRequest_PIXMAP( Window requestor, Atom target, Atom rprop )
1112 {
1113     HANDLE hClipData = 0;
1114     Pixmap pixmap = 0;
1115     UINT   wFormat;
1116     char * itemFmtName;
1117     int xRc;
1118 #if(0)
1119     XSetWindowAttributes win_attr;
1120     XWindowAttributes win_attr_src;
1121 #endif
1122
1123     /*
1124      * Map the requested X selection property type atom name to a
1125      * windows clipboard format ID.
1126      */
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);
1132
1133     hClipData = GetClipboardData(wFormat);
1134     if ( !hClipData )
1135     {
1136         TRACE("Could not retrieve a Pixmap compatible format from clipboard!\n");
1137         rprop = None; /* Fail the request */
1138         goto END;
1139     }
1140
1141     if (wFormat == CF_DIB)
1142     {
1143         HWND hwnd = GetOpenClipboardWindow();
1144         HDC hdc = GetDC(hwnd);
1145
1146         /* For convert from packed DIB to Pixmap */
1147         pixmap = X11DRV_DIB_CreatePixmapFromDIB(hClipData, hdc);
1148
1149         ReleaseDC(hdc, hwnd);
1150     }
1151     else if (wFormat == CF_BITMAP)
1152     {
1153         HWND hwnd = GetOpenClipboardWindow();
1154         HDC hdc = GetDC(hwnd);
1155
1156         pixmap = X11DRV_BITMAP_CreatePixmapFromBitmap(hClipData, hdc);
1157
1158         ReleaseDC(hdc, hwnd);
1159     }
1160     else
1161     {
1162         FIXME("%s to PIXMAP conversion not yet implemented!\n",
1163                       CLIPBOARD_GetFormatName(wFormat));
1164         rprop = None;
1165         goto END;
1166     }
1167
1168     TRACE("\tUpdating property %s on Window %ld with %s %ld...\n",
1169           TSXGetAtomName(display, rprop), (long)requestor,
1170           TSXGetAtomName(display, target), pixmap);
1171
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);
1177
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.
1182      */
1183 #if(0)
1184     /* Express interest in property notify events so that we can delete the
1185      * pixmap when the client deletes the property atom.
1186      */
1187     xRc = TSXGetWindowAttributes(display, requestor, &win_attr_src);
1188     TRACE("Turning on PropertyChangeEvent notifications from window %ld\n",
1189           (long)requestor);
1190     win_attr.event_mask = win_attr_src.your_event_mask | PropertyChangeMask;
1191     TSXChangeWindowAttributes(display, requestor, CWEventMask, &win_attr);
1192
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.
1196      */
1197     X11DRV_CLIPBOARD_RegisterPixmapResource( rprop, pixmap );
1198 #endif
1199
1200 END:
1201     return rprop;
1202 }
1203
1204
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.
1209  */
1210 static Atom EVENT_SelectionRequest_WCF( Window requestor, Atom target, Atom rprop )
1211 {
1212     HANDLE hClipData = 0;
1213     void*  lpClipData;
1214     UINT   wFormat;
1215     char * itemFmtName;
1216     int cBytes;
1217     int xRc;
1218
1219     /*
1220      * Map the requested X selection property type atom name to a
1221      * windows clipboard format ID.
1222      */
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);
1228
1229     hClipData = GetClipboardData16(wFormat);
1230
1231     if( hClipData && (lpClipData = GlobalLock16(hClipData)) )
1232     {
1233         cBytes = GlobalSize16(hClipData);
1234
1235         TRACE("\tUpdating property %s, %d bytes...\n",
1236               TSXGetAtomName(display, rprop), cBytes);
1237
1238         xRc = TSXChangeProperty(display, requestor, rprop,
1239                                 target, 8, PropModeReplace,
1240                                 (unsigned char *)lpClipData, cBytes);
1241         TRACE("(Rc=%d)\n", xRc);
1242
1243         GlobalUnlock16(hClipData);
1244     }
1245     else
1246     {
1247         TRACE("\tCould not retrieve native format!\n");
1248         rprop = None; /* Fail the request */
1249     }
1250
1251     return rprop;
1252 }
1253
1254
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.
1266  */
1267 static Atom EVENT_SelectionRequest_MULTIPLE( HWND hWnd, XSelectionRequestEvent *pevent )
1268 {
1269     Atom           rprop;
1270     Atom           atype=AnyPropertyType;
1271     int            aformat;
1272     unsigned long  remain;
1273     Atom*          targetPropList=NULL;
1274     unsigned long  cTargetPropList = 0;
1275 /*  Atom           xAtomPair = TSXInternAtom(display, "ATOM_PAIR", False); */
1276
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.
1279     */
1280     rprop = pevent->property;
1281     if( rprop == None )
1282         rprop = pevent->target;
1283     if (!rprop)
1284         goto END;
1285
1286     /* Read the MULTIPLE property contents. This should contain a list of
1287      * (target,property) atom pairs.
1288      */
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");
1294     else
1295     {
1296        TRACE("\tType %s,Format %d,nItems %ld, Remain %ld\n",
1297              TSXGetAtomName(display, atype), aformat, cTargetPropList, remain);
1298
1299        /*
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.
1306         */
1307        if(aformat == 32 /* atype == xAtomPair */ )
1308        {
1309           int i;
1310
1311           /* Iterate through the ATOM_PAIR list and execute a SelectionRequest
1312            * for each (target,property) pair */
1313
1314           for (i = 0; i < cTargetPropList; i+=2)
1315           {
1316               char *targetName = TSXGetAtomName(display, targetPropList[i]);
1317               char *propName = TSXGetAtomName(display, targetPropList[i+1]);
1318               XSelectionRequestEvent event;
1319
1320               TRACE("MULTIPLE(%d): Target='%s' Prop='%s'\n",
1321                     i/2, targetName, propName);
1322               TSXFree(targetName);
1323               TSXFree(propName);
1324
1325               /* We must have a non "None" property to service a MULTIPLE target atom */
1326               if ( !targetPropList[i+1] )
1327               {
1328                   TRACE("\tMULTIPLE(%d): Skipping target with empty property!", i);
1329                   continue;
1330               }
1331
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];
1336
1337               /* Fire a SelectionRequest, informing the handler that we are processing
1338                * a MULTIPLE selection request event.
1339                */
1340               EVENT_SelectionRequest( hWnd, &event, TRUE );
1341           }
1342        }
1343
1344        /* Free the list of targets/properties */
1345        TSXFree(targetPropList);
1346     }
1347
1348 END:
1349     return rprop;
1350 }
1351
1352
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.
1358  *
1359  *  Note: We only receive this event when WINE owns the X selection
1360  */
1361 static void EVENT_SelectionRequest( HWND hWnd, XSelectionRequestEvent *event, BOOL bIsMultiple )
1362 {
1363   XSelectionEvent result;
1364   Atom            rprop = None;
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);
1370
1371   /*
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.
1376    */
1377   if ( !bIsMultiple )
1378   {
1379     if ( ( (event->selection != XA_PRIMARY) && (event->selection != xaClipboard) )
1380         || !(couldOpen = OpenClipboard(hWnd)) )
1381        goto END;
1382   }
1383
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.
1386    */
1387   rprop = event->property;
1388   if( rprop == None )
1389       rprop = event->target;
1390
1391   if(event->target == xaTargets)  /*  Return a list of all supported targets */
1392   {
1393       /* TARGETS selection request */
1394       rprop = EVENT_SelectionRequest_TARGETS( request, event->target, rprop );
1395   }
1396   else if(event->target == xaMultiple)  /*  rprop contains a list of (target, property) atom pairs */
1397   {
1398       /* MULTIPLE selection request */
1399       rprop = EVENT_SelectionRequest_MULTIPLE(  hWnd, event );
1400   }
1401   else if(event->target == XA_STRING)  /* treat CF_TEXT as Unix text */
1402   {
1403       /* XA_STRING selection request */
1404       rprop = EVENT_SelectionRequest_STRING( request, event->target, rprop );
1405   }
1406   else if(event->target == XA_PIXMAP)  /*  Convert DIB's to Pixmaps */
1407   {
1408       /* XA_PIXMAP selection request */
1409       rprop = EVENT_SelectionRequest_PIXMAP( request, event->target, rprop );
1410   }
1411   else if(event->target == XA_BITMAP)  /*  Convert DIB's to 1-bit Pixmaps */
1412   {
1413       /* XA_BITMAP selection request - TODO: create a monochrome Pixmap */
1414       rprop = EVENT_SelectionRequest_PIXMAP( request, XA_PIXMAP, rprop );
1415   }
1416   else if(X11DRV_CLIPBOARD_IsNativeProperty(event->target)) /* <WCF>* */
1417   {
1418       /* All <WCF> selection requests */
1419       rprop = EVENT_SelectionRequest_WCF( request, event->target, rprop );
1420   }
1421   else
1422       rprop = None;  /* Don't support this format */
1423
1424 END:
1425   /* close clipboard only if we opened before */
1426   if(couldOpen) CloseClipboard();
1427
1428   if( rprop == None)
1429       TRACE("\tRequest ignored\n");
1430
1431   /* reply to sender
1432    * SelectionNotify should be sent only at the end of a MULTIPLE request
1433    */
1434   if ( !bIsMultiple )
1435   {
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);
1445   }
1446 }
1447
1448 /***********************************************************************
1449  *           EVENT_SelectionClear
1450  */
1451 static void EVENT_SelectionClear( HWND hWnd, XSelectionClearEvent *event )
1452 {
1453   Atom xaClipboard = TSXInternAtom(display, "CLIPBOARD", False);
1454
1455   if (event->selection == XA_PRIMARY || event->selection == xaClipboard)
1456       X11DRV_CLIPBOARD_ReleaseSelection( event->selection, event->window, hWnd );
1457 }
1458
1459 /***********************************************************************
1460  *           EVENT_PropertyNotify
1461  *   We use this to release resources like Pixmaps when a selection
1462  *   client no longer needs them.
1463  */
1464 static void EVENT_PropertyNotify( XPropertyEvent *event )
1465 {
1466   /* Check if we have any resources to free */
1467   TRACE("Received PropertyNotify event: ");
1468
1469   switch(event->state)
1470   {
1471     case PropertyDelete:
1472     {
1473       TRACE("\tPropertyDelete for atom %s on window %ld\n",
1474             TSXGetAtomName(event->display, event->atom), (long)event->window);
1475
1476       if (X11DRV_CLIPBOARD_IsSelectionowner())
1477           X11DRV_CLIPBOARD_FreeResources( event->atom );
1478       break;
1479     }
1480
1481     case PropertyNewValue:
1482     {
1483       TRACE("\tPropertyNewValue for atom %s on window %ld\n\n",
1484             TSXGetAtomName(event->display, event->atom), (long)event->window);
1485       break;
1486     }
1487
1488     default:
1489       break;
1490   }
1491 }
1492
1493 /**********************************************************************
1494  *           EVENT_DropFromOffix
1495  *
1496  * don't know if it still works (last Changlog is from 96/11/04)
1497  */
1498 static void EVENT_DropFromOffiX( HWND hWnd, XClientMessageEvent *event )
1499 {
1500   unsigned long         data_length;
1501   unsigned long         aux_long;
1502   unsigned char*        p_data = NULL;
1503   union {
1504     Atom                atom_aux;
1505     struct {
1506       int x;
1507       int y;
1508     } pt_aux;
1509     int         i;
1510   }             u;
1511   int                   x, y;
1512   BOOL16                bAccept;
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;
1517   WND*                  pDropWnd;
1518   WND*                  pWnd;
1519
1520   if( !lpDragInfo || !spDragInfo ) return;
1521
1522   pWnd = WIN_FindWndPtr(hWnd);
1523
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);
1527
1528   lpDragInfo->hScope = hWnd;
1529   lpDragInfo->pt.x = (INT16)x; lpDragInfo->pt.y = (INT16)y;
1530
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; }
1536   else
1537     {
1538       bAccept = DRAG_QueryUpdate( hWnd, spDragInfo, TRUE );
1539       x = lpDragInfo->pt.x; y = lpDragInfo->pt.y;
1540     }
1541   pDropWnd = WIN_FindWndPtr( lpDragInfo->hScope );
1542   WIN_ReleaseWndPtr(pWnd);
1543
1544   GlobalFree16( hDragInfo );
1545
1546   if( bAccept )
1547     {
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);
1552
1553       if( !aux_long && p_data)  /* don't bother if > 64K */
1554         {
1555           char *p = (char*) p_data;
1556           char *p_drop;
1557
1558           aux_long = 0;
1559           while( *p )   /* calculate buffer size */
1560             {
1561               p_drop = p;
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" */
1565               else
1566                 {
1567                   INT len = GetShortPathNameA( p, NULL, 0 );
1568                   if (len) aux_long += len + 1;
1569                   else *p = -1;
1570                 }
1571               p += strlen(p) + 1;
1572             }
1573           if( aux_long && aux_long < 65535 )
1574             {
1575               HDROP16                 hDrop;
1576               LPDROPFILESTRUCT16        lpDrop;
1577
1578               aux_long += sizeof(DROPFILESTRUCT16) + 1;
1579               hDrop = (HDROP16)GlobalAlloc16( GMEM_SHARE, aux_long );
1580               lpDrop = (LPDROPFILESTRUCT16) GlobalLock16( hDrop );
1581
1582               if( lpDrop )
1583                 {
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);
1593                   p = p_data;
1594                   while(*p)
1595                     {
1596                       if( *p != -1 )    /* use only "good" entries */
1597                         {
1598                           GetShortPathNameA( p, p_drop, 65535 );
1599                           p_drop += strlen( p_drop ) + 1;
1600                         }
1601                       p += strlen(p) + 1;
1602                     }
1603                   *p_drop = '\0';
1604                   PostMessage16( hWnd, WM_DROPFILES,
1605                                  (WPARAM16)hDrop, 0L );
1606                 }
1607             }
1608         }
1609       if( p_data ) TSXFree(p_data);
1610
1611     } /* WS_EX_ACCEPTFILES */
1612
1613   WIN_ReleaseWndPtr(pDropWnd);
1614 }
1615
1616 /**********************************************************************
1617  *           EVENT_DropURLs
1618  *
1619  * drop items are separated by \n
1620  * each item is prefixed by its mime type
1621  *
1622  * event->data.l[3], event->data.l[4] contains drop x,y position
1623  */
1624 static void EVENT_DropURLs( HWND hWnd, XClientMessageEvent *event )
1625 {
1626   WND           *pDropWnd;
1627   WND           *pWnd;
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;
1632   char          *p, *next;
1633   int           x, y, drop32 = FALSE ;
1634   union {
1635     Atom        atom_aux;
1636     int         i;
1637     Window      w_aux;
1638   }             u; /* unused */
1639   union {
1640     HDROP16     h16;
1641     HDROP     h32;
1642   } hDrop;
1643
1644   pWnd = WIN_FindWndPtr(hWnd);
1645   drop32 = pWnd->flags & WIN_ISWIN32;
1646
1647   if (!(pWnd->dwExStyle & WS_EX_ACCEPTFILES))
1648   {
1649     WIN_ReleaseWndPtr(pWnd);
1650     return;
1651   }
1652   WIN_ReleaseWndPtr(pWnd);
1653
1654   TSXGetWindowProperty( display, DefaultRootWindow(display),
1655                         dndSelection, 0, 65535, FALSE,
1656                         AnyPropertyType, &u.atom_aux, &u.i,
1657                         &data_length, &aux_long, &p_data);
1658   if (aux_long)
1659     WARN("property too large, truncated!\n");
1660   TRACE("urls=%s\n", p_data);
1661
1662   if( !aux_long && p_data) {    /* don't bother if > 64K */
1663     /* calculate length */
1664     p = p_data;
1665     next = strchr(p, '\n');
1666     while (p) {
1667       if (next) *next=0;
1668       if (strncmp(p,"file:",5) == 0 ) {
1669         INT len = GetShortPathNameA( p+5, NULL, 0 );
1670         if (len) drop_len += len + 1;
1671       }
1672       if (next) {
1673         *next = '\n';
1674         p = next + 1;
1675         next = strchr(p, '\n');
1676       } else {
1677         p = NULL;
1678       }
1679     }
1680
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);
1684
1685       pDropWnd = WIN_FindWndPtr( hWnd );
1686
1687       if (drop32) {
1688         LPDROPFILESTRUCT        lpDrop;
1689         drop_len += sizeof(DROPFILESTRUCT) + 1;
1690         hDrop.h32 = (HDROP)GlobalAlloc( GMEM_SHARE, drop_len );
1691         lpDrop = (LPDROPFILESTRUCT) GlobalLock( hDrop.h32 );
1692
1693         if( lpDrop ) {
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);
1704         }
1705       } else {
1706         LPDROPFILESTRUCT16        lpDrop;
1707         drop_len += sizeof(DROPFILESTRUCT16) + 1;
1708         hDrop.h16 = (HDROP16)GlobalAlloc16( GMEM_SHARE, drop_len );
1709         lpDrop = (LPDROPFILESTRUCT16) GlobalLock16( hDrop.h16 );
1710
1711         if( lpDrop ) {
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);
1721         }
1722       }
1723
1724       /* create message content */
1725       if (p_drop) {
1726         p = p_data;
1727         next = strchr(p, '\n');
1728         while (p) {
1729           if (next) *next=0;
1730           if (strncmp(p,"file:",5) == 0 ) {
1731             INT len = GetShortPathNameA( p+5, p_drop, 65535 );
1732             if (len) {
1733               TRACE("drop file %s as %s\n", p+5, p_drop);
1734               p_drop += len+1;
1735             } else {
1736               WARN("can't convert file %s to dos name \n", p+5);
1737             }
1738           } else {
1739             WARN("unknown mime type %s\n", p);
1740           }
1741           if (next) {
1742             *next = '\n';
1743             p = next + 1;
1744             next = strchr(p, '\n');
1745           } else {
1746             p = NULL;
1747           }
1748           *p_drop = '\0';
1749         }
1750
1751         if (drop32) {
1752           /* can not use PostMessage32A because it is currently based on
1753            * PostMessage16 and WPARAM32 would be truncated to WPARAM16
1754            */
1755           GlobalUnlock(hDrop.h32);
1756           SendMessageA( hWnd, WM_DROPFILES,
1757                           (WPARAM)hDrop.h32, 0L );
1758         } else {
1759           GlobalUnlock16(hDrop.h16);
1760           PostMessage16( hWnd, WM_DROPFILES,
1761                          (WPARAM16)hDrop.h16, 0L );
1762         }
1763       }
1764       WIN_ReleaseWndPtr(pDropWnd);
1765     }
1766     if( p_data ) TSXFree(p_data);
1767   }
1768 }
1769
1770 /**********************************************************************
1771  *           EVENT_ClientMessage
1772  */
1773 static void EVENT_ClientMessage( HWND hWnd, XClientMessageEvent *event )
1774 {
1775   if (event->message_type != None && event->format == 32) {
1776     if ((event->message_type == wmProtocols) &&
1777         (((Atom) event->data.l[0]) == wmDeleteWindow))
1778     {
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.
1782        */
1783       BOOL bIsDisabled;
1784       bIsDisabled = GetWindowLongA( hWnd, GWL_STYLE ) & WS_DISABLED;
1785
1786       if ( !Options.managed || !bIsDisabled )
1787       PostMessage16( hWnd, WM_SYSCOMMAND, SC_CLOSE, 0 );
1788     }
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);
1795     else {
1796 #if 0
1797       /* enable this if you want to see the message */
1798       unsigned char* p_data = NULL;
1799       union {
1800         unsigned long   l;
1801         int             i;
1802         Atom            atom;
1803       } u; /* unused */
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],
1811             p_data);
1812 #endif
1813       TRACE("unrecognized ClientMessage\n" );
1814     }
1815   }
1816 }
1817
1818 /**********************************************************************
1819  *           EVENT_EnterNotify
1820  *
1821  * Install colormap when Wine window is focused in
1822  * self-managed mode with private colormap
1823  */
1824 #if 0
1825 void EVENT_EnterNotify( HWND hWnd, XCrossingEvent *event )
1826 {
1827   if( !Options.managed && X11DRV_GetXRootWindow() == DefaultRootWindow(display) &&
1828       (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE) && GetFocus() )
1829     TSXInstallColormap( display, X11DRV_PALETTE_GetColormap() );
1830 }
1831 #endif
1832
1833 /**********************************************************************
1834  *              EVENT_MapNotify
1835  */
1836 void EVENT_MapNotify( HWND hWnd, XMapEvent *event )
1837 {
1838   HWND hwndFocus = GetFocus();
1839   WND *wndFocus = WIN_FindWndPtr(hwndFocus);
1840   WND *pWnd = WIN_FindWndPtr(hWnd);
1841   if (pWnd->flags & WIN_MANAGED)
1842   {
1843       DCE_InvalidateDCE( pWnd, &pWnd->rectWindow );
1844       pWnd->dwStyle &= ~WS_MINIMIZE;
1845       pWnd->dwStyle |=  WS_VISIBLE;
1846       ShowOwnedPopups(hWnd,TRUE);
1847   }
1848   WIN_ReleaseWndPtr(pWnd);
1849
1850   if (hwndFocus && IsChild( hWnd, hwndFocus ))
1851       X11DRV_WND_SetFocus(wndFocus);
1852
1853   WIN_ReleaseWndPtr(wndFocus);
1854
1855   return;
1856 }
1857
1858
1859 /**********************************************************************
1860  *              EVENT_MapNotify
1861  */
1862 void EVENT_UnmapNotify( HWND hWnd, XUnmapEvent *event )
1863 {
1864   WND *pWnd = WIN_FindWndPtr(hWnd);
1865   if (pWnd->flags & WIN_MANAGED)
1866   {
1867       EndMenu();
1868       if( pWnd->dwStyle & WS_VISIBLE )
1869       {
1870           pWnd->dwStyle |=  WS_MINIMIZE;
1871           pWnd->dwStyle &= ~WS_VISIBLE;
1872           ShowOwnedPopups(hWnd,FALSE);
1873       }
1874   }
1875   WIN_ReleaseWndPtr(pWnd);
1876 }
1877
1878 /***********************************************************************
1879  *           EVENT_MappingNotify
1880  */
1881 static void EVENT_MappingNotify( XMappingEvent *event )
1882 {
1883     TSXRefreshKeyboardMapping(event);
1884
1885     /* reinitialize Wine-X11 driver keyboard table */
1886     X11DRV_KEYBOARD_Init();
1887 }
1888
1889
1890 /**********************************************************************
1891  *              X11DRV_EVENT_SetInputMethod
1892  */
1893 INPUT_TYPE X11DRV_EVENT_SetInputMethod(INPUT_TYPE type)
1894 {
1895   INPUT_TYPE prev = current_input_type;
1896
1897   /* Flag not used yet */
1898   in_transition = FALSE;
1899   current_input_type = type;
1900
1901   return prev;
1902 }
1903
1904 #ifdef HAVE_LIBXXF86DGA2
1905 /**********************************************************************
1906  *              X11DRV_EVENT_SetDGAStatus
1907  */
1908 void X11DRV_EVENT_SetDGAStatus(HWND hwnd, int event_base)
1909 {
1910   if (event_base < 0) {
1911     DGAUsed = FALSE;
1912     DGAhwnd = 0;
1913   } else {
1914     DGAUsed = TRUE;
1915     DGAhwnd = hwnd;
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;
1921   }
1922 }
1923
1924 /* DGA2 event handlers */
1925 static void EVENT_DGAMotionEvent( XDGAMotionEvent *event )
1926 {
1927   MOUSE_SendEvent( MOUSEEVENTF_MOVE,
1928                    event->dx, event->dy,
1929                    X11DRV_EVENT_XStateToKeyState( event->state ),
1930                    event->time - MSG_WineStartTicks,
1931                    DGAhwnd );
1932 }
1933
1934 static void EVENT_DGAButtonPressEvent( XDGAButtonEvent *event )
1935 {
1936   static WORD statusCodes[NB_BUTTONS] =
1937     { MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_RIGHTDOWN };
1938   int buttonNum = event->button - 1;
1939
1940   WORD keystate;
1941
1942   if (buttonNum >= NB_BUTTONS) return;
1943
1944   keystate = X11DRV_EVENT_XStateToKeyState( event->state );
1945
1946   switch (buttonNum)
1947   {
1948     case 0:
1949       keystate |= MK_LBUTTON;
1950       break;
1951     case 1:
1952       keystate |= MK_MBUTTON;
1953       break;
1954     case 2:
1955       keystate |= MK_RBUTTON;
1956       break;
1957   }
1958
1959   MOUSE_SendEvent( statusCodes[buttonNum],
1960                    0, 0,
1961                    keystate,
1962                    event->time - MSG_WineStartTicks,
1963                    DGAhwnd );
1964 }
1965
1966 static void EVENT_DGAButtonReleaseEvent( XDGAButtonEvent *event )
1967 {
1968   static WORD statusCodes[NB_BUTTONS] =
1969     { MOUSEEVENTF_LEFTUP, MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_RIGHTUP };
1970   int buttonNum = event->button - 1;
1971
1972   WORD keystate;
1973
1974   if (buttonNum >= NB_BUTTONS) return;
1975
1976   keystate = X11DRV_EVENT_XStateToKeyState( event->state );
1977
1978   switch (buttonNum)
1979   {
1980     case 0:
1981       keystate &= ~MK_LBUTTON;
1982       break;
1983     case 1:
1984       keystate &= ~MK_MBUTTON;
1985       break;
1986     case 2:
1987       keystate &= ~MK_RBUTTON;
1988       break;
1989   }
1990
1991   MOUSE_SendEvent( statusCodes[buttonNum],
1992                    0, 0,
1993                    keystate,
1994                    event->time - MSG_WineStartTicks,
1995                    DGAhwnd );
1996 }
1997
1998 #endif
1999
2000 #ifdef HAVE_LIBXXSHM
2001
2002 /*
2003 Normal XShm operation:
2004
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
2012
2013 However, this situation can occur for some reason:
2014
2015 X11           service thread    app thread
2016 ------------- ----------------- ------------------------
2017 Expose ->
2018               WM_ERASEBKGND? ->
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
2023
2024 which is why I also wait for shm_read and do XCheckTypedEvent()
2025 calls in the wait loop. This results in:
2026
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
2032               (idle)
2033 */
2034
2035 typedef struct {
2036   Drawable draw;
2037   LONG state, waiter;
2038   HANDLE sema;
2039 } shm_qs;
2040
2041 /* FIXME: this is not pretty */
2042 static HANDLE shm_read = 0;
2043
2044 #define SHM_MAX_Q 4
2045 static volatile shm_qs shm_q[SHM_MAX_Q];
2046
2047 static void EVENT_ShmCompletion( XShmCompletionEvent *event )
2048 {
2049   int n;
2050
2051   TRACE("Got ShmCompletion for drawable %ld (time %ld)\n", event->drawable, GetTickCount() );
2052
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);
2059       }
2060       return;
2061     }
2062
2063   ERR("Got ShmCompletion for unknown drawable %ld\n", event->drawable );
2064 }
2065
2066 int X11DRV_EVENT_PrepareShmCompletion( Drawable dw )
2067 {
2068   int n;
2069
2070   if (!shm_read)
2071       shm_read = FILE_DupUnixHandle( ConnectionNumber(display), GENERIC_READ | SYNCHRONIZE );
2072
2073   for (n=0; n<SHM_MAX_Q; n++)
2074     if (!shm_q[n].draw)
2075       if (!InterlockedCompareExchange((PVOID*)&shm_q[n].draw, (PVOID)dw, (PVOID)0))
2076         break;
2077
2078   if (n>=SHM_MAX_Q) {
2079     ERR("Maximum number of outstanding ShmCompletions exceeded!\n");
2080     return 0;
2081   }
2082
2083   shm_q[n].state = 0;
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);
2087   }
2088
2089   TRACE("Prepared ShmCompletion (#%d) wait for drawable %ld (thread %lx) (time %ld)\n", n, dw, GetCurrentThreadId(), GetTickCount() );
2090   return n+1;
2091 }
2092
2093 static void X11DRV_EVENT_WaitReplaceShmCompletionInternal( int *compl, Drawable dw, int creat )
2094 {
2095   int n = *compl;
2096   LONG nn, st;
2097   HANDLE sema;
2098
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)))
2102       return;
2103     /* race for compl lost, clear slot */
2104     shm_q[nn-1].draw = 0;
2105     return;
2106   }
2107
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");
2111     return;
2112   }
2113
2114   sema = shm_q[n-1].sema;
2115   if (!sema) {
2116     /* nothing to wait on (PrepareShmCompletion not done yet?), so probably nothing to wait for */
2117     return;
2118   }
2119
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);
2124   } else {
2125     TRACE("Waiting for ShmCompletion (#%d) (thread %lx) (time %ld) (semaphore %x)\n", n-1, GetCurrentThreadId(), GetTickCount(), sema);
2126     if (nn) {
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 );
2130     } else
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 */
2134       XEvent event;
2135       HANDLE hnd[2];
2136
2137       hnd[0] = sema;
2138       hnd[1] = shm_read;
2139       do {
2140         /* check X event queue */
2141         if (TSXCheckTypedEvent( display, ShmCompletionType, &event)) {
2142           EVENT_ProcessEvent( &event );
2143         }
2144       } while ( WaitForMultipleObjects(2, hnd, FALSE, INFINITE) > WAIT_OBJECT_0 );
2145     }
2146     TRACE("Wait complete (thread %lx) (time %ld)\n", GetCurrentThreadId(), GetTickCount() );
2147
2148     /* clear wait */
2149     st = InterlockedExchange((LPLONG)&shm_q[n-1].state, 2);
2150     if (st != 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);
2155     }
2156   }
2157   nn = InterlockedDecrement((LPLONG)&shm_q[n-1].waiter);
2158   if (!nn) {
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;
2162   }
2163 }
2164
2165 void X11DRV_EVENT_WaitReplaceShmCompletion( int *compl, Drawable dw )
2166 {
2167   X11DRV_EVENT_WaitReplaceShmCompletionInternal( compl, dw, 1 );
2168 }
2169
2170 void X11DRV_EVENT_WaitShmCompletion( int compl )
2171 {
2172   if (!compl) return;
2173   X11DRV_EVENT_WaitReplaceShmCompletionInternal( &compl, 0, 0 );
2174 }
2175
2176 void X11DRV_EVENT_WaitShmCompletions( Drawable dw )
2177 {
2178   int n;
2179
2180   for (n=0; n<SHM_MAX_Q; n++)
2181     if (shm_q[n].draw == dw)
2182       X11DRV_EVENT_WaitShmCompletion( n+1 );
2183 }
2184
2185 #endif /* defined(HAVE_LIBXXSHM) */