dlls/winex11.drv/event.c

   1 /*
   2  * X11 event driver
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1999 Noel Borthwick
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23
  24 #ifdef HAVE_POLL_H
  25 #include <poll.h>
  26 #endif
  27 #ifdef HAVE_SYS_POLL_H
  28 #include <sys/poll.h>
  29 #endif
  30 #include <X11/Xatom.h>
  31 #include <X11/keysym.h>
  32 #include <X11/Xlib.h>
  33 #include <X11/Xresource.h>
  34 #include <X11/Xutil.h>
  35
  36 #include <assert.h>
  37 #include <stdarg.h>
  38 #include <string.h>
  39
  40 #define NONAMELESSUNION
  41 #define NONAMELESSSTRUCT
  42 #include "windef.h"
  43 #include "winbase.h"
  44 #include "winuser.h"
  45 #include "wingdi.h"
  46
  47 #include "x11drv.h"
  48
  49 /* avoid conflict with field names in included win32 headers */
  50 #undef Status
  51 #include "shlobj.h"  /* DROPFILES */
  52 #include "shellapi.h"
  53
  54 #include "wine/server.h"
  55 #include "wine/debug.h"
  56
  57 WINE_DEFAULT_DEBUG_CHANNEL(event);
  58
  59 extern BOOL ximInComposeMode;
  60
  61 #define DndNotDnd       -1    /* OffiX drag&drop */
  62 #define DndUnknown      0
  63 #define DndRawData      1
  64 #define DndFile         2
  65 #define DndFiles        3
  66 #define DndText         4
  67 #define DndDir          5
  68 #define DndLink         6
  69 #define DndExe          7
  70
  71 #define DndEND          8
  72
  73 #define DndURL          128   /* KDE drag&drop */
  74
  75   /* Event handlers */
  76 static void X11DRV_FocusIn( HWND hwnd, XEvent *event );
  77 static void X11DRV_FocusOut( HWND hwnd, XEvent *event );
  78 static void X11DRV_Expose( HWND hwnd, XEvent *event );
  79 static void X11DRV_MapNotify( HWND hwnd, XEvent *event );
  80 static void X11DRV_ConfigureNotify( HWND hwnd, XEvent *event );
  81 static void X11DRV_PropertyNotify( HWND hwnd, XEvent *event );
  82 static void X11DRV_ClientMessage( HWND hwnd, XEvent *event );
  83
  84 struct event_handler
  85 {
  86     int                  type;    /* event type */
  87     x11drv_event_handler handler; /* corresponding handler function */
  88 };
  89
  90 #define MAX_EVENT_HANDLERS 64
  91
  92 static struct event_handler handlers[MAX_EVENT_HANDLERS] =
  93 {
  94     /* list must be sorted by event type */
  95     { KeyPress,         X11DRV_KeyEvent },
  96     { KeyRelease,       X11DRV_KeyEvent },
  97     { ButtonPress,      X11DRV_ButtonPress },
  98     { ButtonRelease,    X11DRV_ButtonRelease },
  99     { MotionNotify,     X11DRV_MotionNotify },
 100     { EnterNotify,      X11DRV_EnterNotify },
 101     /* LeaveNotify */
 102     { FocusIn,          X11DRV_FocusIn },
 103     { FocusOut,         X11DRV_FocusOut },
 104     { KeymapNotify,     X11DRV_KeymapNotify },
 105     { Expose,           X11DRV_Expose },
 106     /* GraphicsExpose */
 107     /* NoExpose */
 108     /* VisibilityNotify */
 109     /* CreateNotify */
 110     { DestroyNotify,    X11DRV_DestroyNotify },
 111     /* UnmapNotify */
 112     { MapNotify,        X11DRV_MapNotify },
 113     /* MapRequest */
 114     /* ReparentNotify */
 115     { ConfigureNotify,  X11DRV_ConfigureNotify },
 116     /* ConfigureRequest */
 117     /* GravityNotify */
 118     /* ResizeRequest */
 119     /* CirculateNotify */
 120     /* CirculateRequest */
 121     { PropertyNotify,   X11DRV_PropertyNotify },
 122     { SelectionClear,   X11DRV_SelectionClear },
 123     { SelectionRequest, X11DRV_SelectionRequest },
 124     /* SelectionNotify */
 125     /* ColormapNotify */
 126     { ClientMessage,    X11DRV_ClientMessage },
 127     { MappingNotify,    X11DRV_MappingNotify },
 128 };
 129
 130 static int nb_event_handlers = 18;  /* change this if you add handlers above */
 131
 132
 133 /* return the name of an X event */
 134 static const char *dbgstr_event( int type )
 135 {
 136     static const char * const event_names[] =
 137     {
 138         "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease",
 139         "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut",
 140         "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify",
 141         "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",
 142         "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify",
 143         "ResizeRequest", "CirculateNotify", "CirculateRequest", "PropertyNotify",
 144         "SelectionClear", "SelectionRequest", "SelectionNotify", "ColormapNotify",
 145         "ClientMessage", "MappingNotify"
 146     };
 147
 148     if (type >= KeyPress && type <= MappingNotify) return event_names[type - KeyPress];
 149     return wine_dbg_sprintf( "Extension event %d", type );
 150 }
 151
 152
 153 /***********************************************************************
 154  *           find_handler
 155  *
 156  * Find the handler for a given event type. Caller must hold the x11 lock.
 157  */
 158 static inline x11drv_event_handler find_handler( int type )
 159 {
 160     int min = 0, max = nb_event_handlers - 1;
 161
 162     while (min <= max)
 163     {
 164         int pos = (min + max) / 2;
 165         if (handlers[pos].type == type) return handlers[pos].handler;
 166         if (handlers[pos].type > type) max = pos - 1;
 167         else min = pos + 1;
 168     }
 169     return NULL;
 170 }
 171
 172
 173 /***********************************************************************
 174  *           X11DRV_register_event_handler
 175  *
 176  * Register a handler for a given event type.
 177  * If already registered, overwrite the previous handler.
 178  */
 179 void X11DRV_register_event_handler( int type, x11drv_event_handler handler )
 180 {
 181     int min, max;
 182
 183     wine_tsx11_lock();
 184     min = 0;
 185     max = nb_event_handlers - 1;
 186     while (min <= max)
 187     {
 188         int pos = (min + max) / 2;
 189         if (handlers[pos].type == type)
 190         {
 191             handlers[pos].handler = handler;
 192             goto done;
 193         }
 194         if (handlers[pos].type > type) max = pos - 1;
 195         else min = pos + 1;
 196     }
 197     /* insert it between max and min */
 198     memmove( &handlers[min+1], &handlers[min], (nb_event_handlers - min) * sizeof(handlers[0]) );
 199     handlers[min].type = type;
 200     handlers[min].handler = handler;
 201     nb_event_handlers++;
 202     assert( nb_event_handlers <= MAX_EVENT_HANDLERS );
 203 done:
 204     wine_tsx11_unlock();
 205     TRACE("registered handler %p for event %d count %d\n", handler, type, nb_event_handlers );
 206 }
 207
 208
 209 /***********************************************************************
 210  *           filter_event
 211  */
 212 static Bool filter_event( Display *display, XEvent *event, char *arg )
 213 {
 214     ULONG_PTR mask = (ULONG_PTR)arg;
 215
 216     if ((mask & QS_ALLINPUT) == QS_ALLINPUT) return 1;
 217
 218     switch(event->type)
 219     {
 220     case KeyPress:
 221     case KeyRelease:
 222     case KeymapNotify:
 223     case MappingNotify:
 224         return (mask & QS_KEY) != 0;
 225     case ButtonPress:
 226     case ButtonRelease:
 227         return (mask & QS_MOUSEBUTTON) != 0;
 228     case MotionNotify:
 229     case EnterNotify:
 230     case LeaveNotify:
 231         return (mask & QS_MOUSEMOVE) != 0;
 232     case Expose:
 233         return (mask & QS_PAINT) != 0;
 234     case FocusIn:
 235     case FocusOut:
 236     case MapNotify:
 237     case UnmapNotify:
 238     case ConfigureNotify:
 239     case PropertyNotify:
 240     case ClientMessage:
 241         return (mask & QS_POSTMESSAGE) != 0;
 242     default:
 243         return (mask & QS_SENDMESSAGE) != 0;
 244     }
 245 }
 246
 247
 248 enum event_merge_action
 249 {
 250     MERGE_DISCARD,  /* discard the old event */
 251     MERGE_HANDLE,   /* handle the old event */
 252     MERGE_KEEP      /* keep the old event for future merging */
 253 };
 254
 255 /***********************************************************************
 256  *           merge_events
 257  *
 258  * Try to merge 2 consecutive events.
 259  */
 260 static enum event_merge_action merge_events( XEvent *prev, XEvent *next )
 261 {
 262     switch (prev->type)
 263     {
 264     case ConfigureNotify:
 265         switch (next->type)
 266         {
 267         case ConfigureNotify:
 268             if (prev->xany.window == next->xany.window)
 269             {
 270                 TRACE( "discarding duplicate ConfigureNotify for window %lx\n", prev->xany.window );
 271                 return MERGE_DISCARD;
 272             }
 273             break;
 274         case Expose:
 275         case PropertyNotify:
 276             return MERGE_KEEP;
 277         }
 278         break;
 279     case MotionNotify:
 280         if (prev->xany.window == next->xany.window && next->type == MotionNotify)
 281         {
 282             TRACE( "discarding duplicate MotionNotify for window %lx\n", prev->xany.window );
 283             return MERGE_DISCARD;
 284         }
 285         break;
 286     }
 287     return MERGE_HANDLE;
 288 }
 289
 290
 291 /***********************************************************************
 292  *           call_event_handler
 293  */
 294 static inline void call_event_handler( Display *display, XEvent *event )
 295 {
 296     HWND hwnd;
 297     x11drv_event_handler handler;
 298     XEvent *prev;
 299     struct x11drv_thread_data *thread_data;
 300
 301     if (!(handler = find_handler( event->type )))
 302     {
 303         TRACE( "%s for win %lx, ignoring\n", dbgstr_event( event->type ), event->xany.window );
 304         return;  /* no handler, ignore it */
 305     }
 306
 307     if (XFindContext( display, event->xany.window, winContext, (char **)&hwnd ) != 0)
 308         hwnd = 0;  /* not for a registered window */
 309     if (!hwnd && event->xany.window == root_window) hwnd = GetDesktopWindow();
 310
 311     TRACE( "%lu %s for hwnd/window %p/%lx\n",
 312            event->xany.serial, dbgstr_event( event->type ), hwnd, event->xany.window );
 313     wine_tsx11_unlock();
 314     thread_data = x11drv_thread_data();
 315     prev = thread_data->current_event;
 316     thread_data->current_event = event;
 317     handler( hwnd, event );
 318     thread_data->current_event = prev;
 319     wine_tsx11_lock();
 320 }
 321
 322
 323 /***********************************************************************
 324  *           process_events
 325  */
 326 static int process_events( Display *display, Bool (*filter)(Display*, XEvent*,XPointer), ULONG_PTR arg )
 327 {
 328     XEvent event, prev_event;
 329     int count = 0;
 330     enum event_merge_action action = MERGE_DISCARD;
 331
 332     prev_event.type = 0;
 333     wine_tsx11_lock();
 334     while (XCheckIfEvent( display, &event, filter, (char *)arg ))
 335     {
 336         count++;
 337         if (XFilterEvent( &event, None ))
 338         {
 339             /*
 340              * SCIM on linux filters key events strangely. It does not filter the
 341              * KeyPress events for these keys however it does filter the
 342              * KeyRelease events. This causes wine to become very confused as
 343              * to the keyboard state.
 344              *
 345              * We need to let those KeyRelease events be processed so that the
 346              * keyboard state is correct.
 347              */
 348             if (event.type == KeyRelease)
 349             {
 350                 KeySym keysym = 0;
 351                 XKeyEvent *keyevent = &event.xkey;
 352
 353                 XLookupString(keyevent, NULL, 0, &keysym, NULL);
 354                 if (!(keysym == XK_Shift_L ||
 355                     keysym == XK_Shift_R ||
 356                     keysym == XK_Control_L ||
 357                     keysym == XK_Control_R ||
 358                     keysym == XK_Alt_R ||
 359                     keysym == XK_Alt_L ||
 360                     keysym == XK_Meta_R ||
 361                     keysym == XK_Meta_L))
 362                         continue; /* not a key we care about, ignore it */
 363             }
 364             else
 365                 continue;  /* filtered, ignore it */
 366         }
 367         if (prev_event.type) action = merge_events( &prev_event, &event );
 368         switch( action )
 369         {
 370         case MERGE_DISCARD:  /* discard prev, keep new */
 371             prev_event = event;
 372             break;
 373         case MERGE_HANDLE:  /* handle prev, keep new */
 374             call_event_handler( display, &prev_event );
 375             prev_event = event;
 376             break;
 377         case MERGE_KEEP:  /* handle new, keep prev for future merging */
 378             call_event_handler( display, &event );
 379             break;
 380         }
 381     }
 382     if (prev_event.type) call_event_handler( display, &prev_event );
 383     XFlush( gdi_display );
 384     wine_tsx11_unlock();
 385     if (count) TRACE( "processed %d events\n", count );
 386     return count;
 387 }
 388
 389
 390 /***********************************************************************
 391  *           MsgWaitForMultipleObjectsEx   (X11DRV.@)
 392  */
 393 DWORD CDECL X11DRV_MsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
 394                                                 DWORD timeout, DWORD mask, DWORD flags )
 395 {
 396     DWORD ret;
 397     struct x11drv_thread_data *data = TlsGetValue( thread_data_tls_index );
 398
 399     if (!data)
 400     {
 401         if (!count && !timeout) return WAIT_TIMEOUT;
 402         return WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
 403                                          timeout, flags & MWMO_ALERTABLE );
 404     }
 405
 406     if (data->current_event) mask = 0;  /* don't process nested events */
 407
 408     if (process_events( data->display, filter_event, mask )) ret = count - 1;
 409     else if (count || timeout)
 410     {
 411         ret = WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
 412                                         timeout, flags & MWMO_ALERTABLE );
 413         if (ret == count - 1) process_events( data->display, filter_event, mask );
 414     }
 415     else ret = WAIT_TIMEOUT;
 416
 417     return ret;
 418 }
 419
 420 /***********************************************************************
 421  *           EVENT_x11_time_to_win32_time
 422  *
 423  * Make our timer and the X timer line up as best we can
 424  *  Pass 0 to retrieve the current adjustment value (times -1)
 425  */
 426 DWORD EVENT_x11_time_to_win32_time(Time time)
 427 {
 428   static DWORD adjust = 0;
 429   DWORD now = GetTickCount();
 430   DWORD ret;
 431
 432   if (! adjust && time != 0)
 433   {
 434     ret = now;
 435     adjust = time - now;
 436   }
 437   else
 438   {
 439       /* If we got an event in the 'future', then our clock is clearly wrong.
 440          If we got it more than 10000 ms in the future, then it's most likely
 441          that the clock has wrapped.  */
 442
 443       ret = time - adjust;
 444       if (ret > now && ((ret - now) < 10000) && time != 0)
 445       {
 446         adjust += ret - now;
 447         ret    -= ret - now;
 448       }
 449   }
 450
 451   return ret;
 452
 453 }
 454
 455 /*******************************************************************
 456  *         can_activate_window
 457  *
 458  * Check if we can activate the specified window.
 459  */
 460 static inline BOOL can_activate_window( HWND hwnd )
 461 {
 462     LONG style = GetWindowLongW( hwnd, GWL_STYLE );
 463     if (!(style & WS_VISIBLE)) return FALSE;
 464     if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return FALSE;
 465     if (style & WS_MINIMIZE) return FALSE;
 466     if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOACTIVATE) return FALSE;
 467     if (hwnd == GetDesktopWindow()) return FALSE;
 468     return !(style & WS_DISABLED);
 469 }
 470
 471
 472 /**********************************************************************
 473  *              set_focus
 474  */
 475 static void set_focus( Display *display, HWND hwnd, Time time )
 476 {
 477     HWND focus;
 478     Window win;
 479     GUITHREADINFO threadinfo;
 480
 481     TRACE( "setting foreground window to %p\n", hwnd );
 482     SetForegroundWindow( hwnd );
 483
 484     GetGUIThreadInfo(0, &threadinfo);
 485     focus = threadinfo.hwndFocus;
 486     if (focus) focus = GetAncestor( focus, GA_ROOT );
 487     win = X11DRV_get_whole_window(focus);
 488
 489     if (win)
 490     {
 491         TRACE( "setting focus to %p (%lx) time=%ld\n", focus, win, time );
 492         wine_tsx11_lock();
 493         XSetInputFocus( display, win, RevertToParent, time );
 494         wine_tsx11_unlock();
 495     }
 496 }
 497
 498
 499 /**********************************************************************
 500  *              handle_wm_protocols
 501  */
 502 static void handle_wm_protocols( HWND hwnd, XClientMessageEvent *event )
 503 {
 504     Atom protocol = (Atom)event->data.l[0];
 505
 506     if (!protocol) return;
 507
 508     if (protocol == x11drv_atom(WM_DELETE_WINDOW))
 509     {
 510         if (hwnd == GetDesktopWindow())
 511         {
 512             /* The desktop window does not have a close button that we can
 513              * pretend to click. Therefore, we simply send it a close command. */
 514             SendMessageW(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0);
 515             return;
 516         }
 517
 518         /* Ignore the delete window request if the window has been disabled
 519          * and we are in managed mode. This is to disallow applications from
 520          * being closed by the window manager while in a modal state.
 521          */
 522         if (IsWindowEnabled(hwnd))
 523         {
 524             HMENU hSysMenu;
 525
 526             if (GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE) return;
 527             hSysMenu = GetSystemMenu(hwnd, FALSE);
 528             if (hSysMenu)
 529             {
 530                 UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
 531                 if (state == 0xFFFFFFFF || (state & (MF_DISABLED | MF_GRAYED)))
 532                     return;
 533             }
 534             if (GetActiveWindow() != hwnd)
 535             {
 536                 LRESULT ma = SendMessageW( hwnd, WM_MOUSEACTIVATE,
 537                                            (WPARAM)GetAncestor( hwnd, GA_ROOT ),
 538                                            MAKELPARAM( HTCLOSE, WM_NCLBUTTONDOWN ) );
 539                 switch(ma)
 540                 {
 541                     case MA_NOACTIVATEANDEAT:
 542                     case MA_ACTIVATEANDEAT:
 543                         return;
 544                     case MA_NOACTIVATE:
 545                         break;
 546                     case MA_ACTIVATE:
 547                     case 0:
 548                         SetActiveWindow(hwnd);
 549                         break;
 550                     default:
 551                         WARN( "unknown WM_MOUSEACTIVATE code %d\n", (int) ma );
 552                         break;
 553                 }
 554             }
 555
 556             PostMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, 0 );
 557         }
 558     }
 559     else if (protocol == x11drv_atom(WM_TAKE_FOCUS))
 560     {
 561         Time event_time = (Time)event->data.l[1];
 562         HWND last_focus = x11drv_thread_data()->last_focus;
 563
 564         TRACE( "got take focus msg for %p, enabled=%d, visible=%d (style %08x), focus=%p, active=%p, fg=%p, last=%p\n",
 565                hwnd, IsWindowEnabled(hwnd), IsWindowVisible(hwnd), GetWindowLongW(hwnd, GWL_STYLE),
 566                GetFocus(), GetActiveWindow(), GetForegroundWindow(), last_focus );
 567
 568         if (can_activate_window(hwnd))
 569         {
 570             /* simulate a mouse click on the caption to find out
 571              * whether the window wants to be activated */
 572             LRESULT ma = SendMessageW( hwnd, WM_MOUSEACTIVATE,
 573                                        (WPARAM)GetAncestor( hwnd, GA_ROOT ),
 574                                        MAKELONG(HTCAPTION,WM_LBUTTONDOWN) );
 575             if (ma != MA_NOACTIVATEANDEAT && ma != MA_NOACTIVATE)
 576             {
 577                 set_focus( event->display, hwnd, event_time );
 578                 return;
 579             }
 580         }
 581         else if (hwnd == GetDesktopWindow())
 582         {
 583             hwnd = GetForegroundWindow();
 584             if (!hwnd) hwnd = last_focus;
 585             if (!hwnd) hwnd = GetDesktopWindow();
 586             set_focus( event->display, hwnd, event_time );
 587             return;
 588         }
 589         /* try to find some other window to give the focus to */
 590         hwnd = GetFocus();
 591         if (hwnd) hwnd = GetAncestor( hwnd, GA_ROOT );
 592         if (!hwnd) hwnd = GetActiveWindow();
 593         if (!hwnd) hwnd = last_focus;
 594         if (hwnd && can_activate_window(hwnd)) set_focus( event->display, hwnd, event_time );
 595     }
 596     else if (protocol == x11drv_atom(_NET_WM_PING))
 597     {
 598       XClientMessageEvent xev;
 599       xev = *event;
 600
 601       TRACE("NET_WM Ping\n");
 602       wine_tsx11_lock();
 603       xev.window = DefaultRootWindow(xev.display);
 604       XSendEvent(xev.display, xev.window, False, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent*)&xev);
 605       wine_tsx11_unlock();
 606       /* this line is semi-stolen from gtk2 */
 607       TRACE("NET_WM Pong\n");
 608     }
 609 }
 610
 611
 612 static const char * const focus_details[] =
 613 {
 614     "NotifyAncestor",
 615     "NotifyVirtual",
 616     "NotifyInferior",
 617     "NotifyNonlinear",
 618     "NotifyNonlinearVirtual",
 619     "NotifyPointer",
 620     "NotifyPointerRoot",
 621     "NotifyDetailNone"
 622 };
 623
 624 /**********************************************************************
 625  *              X11DRV_FocusIn
 626  */
 627 static void X11DRV_FocusIn( HWND hwnd, XEvent *xev )
 628 {
 629     XFocusChangeEvent *event = &xev->xfocus;
 630     XIC xic;
 631
 632     if (!hwnd) return;
 633
 634     TRACE( "win %p xwin %lx detail=%s\n", hwnd, event->window, focus_details[event->detail] );
 635
 636     if (event->detail == NotifyPointer) return;
 637
 638     if ((xic = X11DRV_get_ic( hwnd )))
 639     {
 640         wine_tsx11_lock();
 641         XSetICFocus( xic );
 642         wine_tsx11_unlock();
 643     }
 644     if (use_take_focus) return;  /* ignore FocusIn if we are using take focus */
 645
 646     if (!can_activate_window(hwnd))
 647     {
 648         HWND hwnd = GetFocus();
 649         if (hwnd) hwnd = GetAncestor( hwnd, GA_ROOT );
 650         if (!hwnd) hwnd = GetActiveWindow();
 651         if (!hwnd) hwnd = x11drv_thread_data()->last_focus;
 652         if (hwnd && can_activate_window(hwnd)) set_focus( event->display, hwnd, CurrentTime );
 653     }
 654     else SetForegroundWindow( hwnd );
 655 }
 656
 657
 658 /**********************************************************************
 659  *              X11DRV_FocusOut
 660  *
 661  * Note: only top-level windows get FocusOut events.
 662  */
 663 static void X11DRV_FocusOut( HWND hwnd, XEvent *xev )
 664 {
 665     XFocusChangeEvent *event = &xev->xfocus;
 666     HWND hwnd_tmp;
 667     Window focus_win;
 668     int revert;
 669     XIC xic;
 670
 671     if (!hwnd) return;
 672
 673     TRACE( "win %p xwin %lx detail=%s\n", hwnd, event->window, focus_details[event->detail] );
 674
 675     if (event->detail == NotifyPointer) return;
 676     if (ximInComposeMode) return;
 677
 678     x11drv_thread_data()->last_focus = hwnd;
 679     if ((xic = X11DRV_get_ic( hwnd )))
 680     {
 681         wine_tsx11_lock();
 682         XUnsetICFocus( xic );
 683         wine_tsx11_unlock();
 684     }
 685     if (hwnd != GetForegroundWindow()) return;
 686     if (root_window != DefaultRootWindow(event->display)) return;
 687     SendMessageW( hwnd, WM_CANCELMODE, 0, 0 );
 688
 689     /* don't reset the foreground window, if the window which is
 690        getting the focus is a Wine window */
 691
 692     wine_tsx11_lock();
 693     XGetInputFocus( event->display, &focus_win, &revert );
 694     if (focus_win)
 695     {
 696         if (XFindContext( event->display, focus_win, winContext, (char **)&hwnd_tmp ) != 0)
 697             focus_win = 0;
 698     }
 699     wine_tsx11_unlock();
 700
 701     if (!focus_win)
 702     {
 703         /* Abey : 6-Oct-99. Check again if the focus out window is the
 704            Foreground window, because in most cases the messages sent
 705            above must have already changed the foreground window, in which
 706            case we don't have to change the foreground window to 0 */
 707         if (hwnd == GetForegroundWindow())
 708         {
 709             TRACE( "lost focus, setting fg to desktop\n" );
 710             SetForegroundWindow( GetDesktopWindow() );
 711         }
 712     }
 713 }
 714
 715
 716 /***********************************************************************
 717  *           X11DRV_Expose
 718  */
 719 static void X11DRV_Expose( HWND hwnd, XEvent *xev )
 720 {
 721     XExposeEvent *event = &xev->xexpose;
 722     RECT rect;
 723     struct x11drv_win_data *data;
 724     int flags = RDW_INVALIDATE | RDW_ERASE;
 725
 726     TRACE( "win %p (%lx) %d,%d %dx%d\n",
 727            hwnd, event->window, event->x, event->y, event->width, event->height );
 728
 729     if (!(data = X11DRV_get_win_data( hwnd ))) return;
 730
 731     if (event->window == data->whole_window)
 732     {
 733         rect.left = data->whole_rect.left + event->x;
 734         rect.top  = data->whole_rect.top + event->y;
 735         flags |= RDW_FRAME;
 736     }
 737     else
 738     {
 739         rect.left = data->client_rect.left + event->x;
 740         rect.top  = data->client_rect.top + event->y;
 741     }
 742     rect.right  = rect.left + event->width;
 743     rect.bottom = rect.top + event->height;
 744
 745     if (event->window != root_window)
 746     {
 747         SERVER_START_REQ( update_window_zorder )
 748         {
 749             req->window      = wine_server_user_handle( hwnd );
 750             req->rect.left   = rect.left;
 751             req->rect.top    = rect.top;
 752             req->rect.right  = rect.right;
 753             req->rect.bottom = rect.bottom;
 754             wine_server_call( req );
 755         }
 756         SERVER_END_REQ;
 757
 758         /* make position relative to client area instead of parent */
 759         OffsetRect( &rect, -data->client_rect.left, -data->client_rect.top );
 760         flags |= RDW_ALLCHILDREN;
 761     }
 762
 763     RedrawWindow( hwnd, &rect, 0, flags );
 764 }
 765
 766
 767 /**********************************************************************
 768  *              X11DRV_MapNotify
 769  */
 770 static void X11DRV_MapNotify( HWND hwnd, XEvent *event )
 771 {
 772     struct x11drv_win_data *data;
 773
 774     if (!(data = X11DRV_get_win_data( hwnd ))) return;
 775     if (!data->mapped) return;
 776
 777     if (!data->managed)
 778     {
 779         HWND hwndFocus = GetFocus();
 780         if (hwndFocus && IsChild( hwnd, hwndFocus )) X11DRV_SetFocus(hwndFocus);  /* FIXME */
 781     }
 782 }
 783
 784
 785 /***********************************************************************
 786  *     is_net_wm_state_maximized
 787  */
 788 static BOOL is_net_wm_state_maximized( Display *display, struct x11drv_win_data *data )
 789 {
 790     Atom type, *state;
 791     int format, ret = 0;
 792     unsigned long i, count, remaining;
 793
 794     wine_tsx11_lock();
 795     if (!XGetWindowProperty( display, data->whole_window, x11drv_atom(_NET_WM_STATE), 0,
 796                              65536/sizeof(CARD32), False, XA_ATOM, &type, &format, &count,
 797                              &remaining, (unsigned char **)&state ))
 798     {
 799         if (type == XA_ATOM && format == 32)
 800         {
 801             for (i = 0; i < count; i++)
 802             {
 803                 if (state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_VERT) ||
 804                     state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ))
 805                     ret++;
 806             }
 807         }
 808         XFree( state );
 809     }
 810     wine_tsx11_unlock();
 811     return (ret == 2);
 812 }
 813
 814
 815 /***********************************************************************
 816  *              X11DRV_ConfigureNotify
 817  */
 818 void X11DRV_ConfigureNotify( HWND hwnd, XEvent *xev )
 819 {
 820     XConfigureEvent *event = &xev->xconfigure;
 821     struct x11drv_win_data *data;
 822     RECT rect;
 823     UINT flags;
 824     int cx, cy, x = event->x, y = event->y;
 825
 826     if (!hwnd) return;
 827     if (!(data = X11DRV_get_win_data( hwnd ))) return;
 828     if (!data->mapped || data->iconic || !data->managed) return;
 829     if (data->configure_serial && (long)(data->configure_serial - event->serial) > 0)
 830     {
 831         TRACE( "win %p/%lx event %d,%d,%dx%d ignoring old serial %lu/%lu\n",
 832                hwnd, data->whole_window, event->x, event->y, event->width, event->height,
 833                event->serial, data->configure_serial );
 834         return;
 835     }
 836
 837     /* Get geometry */
 838
 839     if (!event->send_event)  /* normal event, need to map coordinates to the root */
 840     {
 841         Window child;
 842         wine_tsx11_lock();
 843         XTranslateCoordinates( event->display, data->whole_window, root_window,
 844                                0, 0, &x, &y, &child );
 845         wine_tsx11_unlock();
 846     }
 847     rect.left   = x;
 848     rect.top    = y;
 849     rect.right  = x + event->width;
 850     rect.bottom = y + event->height;
 851     OffsetRect( &rect, virtual_screen_rect.left, virtual_screen_rect.top );
 852     TRACE( "win %p/%lx new X rect %d,%d,%dx%d (event %d,%d,%dx%d)\n",
 853            hwnd, data->whole_window, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
 854            event->x, event->y, event->width, event->height );
 855     X11DRV_X_to_window_rect( data, &rect );
 856
 857     if (is_net_wm_state_maximized( event->display, data ))
 858     {
 859         if (!IsZoomed( data->hwnd ))
 860         {
 861             TRACE( "win %p/%lx is maximized\n", data->hwnd, data->whole_window );
 862             SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
 863             return;
 864         }
 865     }
 866     else
 867     {
 868         if (IsZoomed( data->hwnd ))
 869         {
 870             TRACE( "window %p/%lx is no longer maximized\n", data->hwnd, data->whole_window );
 871             SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0 );
 872             return;
 873         }
 874     }
 875
 876     /* Compare what has changed */
 877
 878     x     = rect.left;
 879     y     = rect.top;
 880     cx    = rect.right - rect.left;
 881     cy    = rect.bottom - rect.top;
 882     flags = SWP_NOACTIVATE | SWP_NOZORDER;
 883
 884     if (data->window_rect.left == x && data->window_rect.top == y) flags |= SWP_NOMOVE;
 885     else
 886         TRACE( "%p moving from (%d,%d) to (%d,%d)\n",
 887                hwnd, data->window_rect.left, data->window_rect.top, x, y );
 888
 889     if ((data->window_rect.right - data->window_rect.left == cx &&
 890          data->window_rect.bottom - data->window_rect.top == cy) ||
 891         (IsRectEmpty( &data->window_rect ) && event->width == 1 && event->height == 1))
 892     {
 893         if (flags & SWP_NOMOVE) return;  /* if nothing changed, don't do anything */
 894         flags |= SWP_NOSIZE;
 895     }
 896     else
 897         TRACE( "%p resizing from (%dx%d) to (%dx%d)\n",
 898                hwnd, data->window_rect.right - data->window_rect.left,
 899                data->window_rect.bottom - data->window_rect.top, cx, cy );
 900
 901     SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
 902 }
 903
 904
 905 /***********************************************************************
 906  *           get_window_wm_state
 907  */
 908 static int get_window_wm_state( Display *display, struct x11drv_win_data *data )
 909 {
 910     struct
 911     {
 912         CARD32 state;
 913         XID     icon;
 914     } *state;
 915     Atom type;
 916     int format, ret = -1;
 917     unsigned long count, remaining;
 918
 919     wine_tsx11_lock();
 920     if (!XGetWindowProperty( display, data->whole_window, x11drv_atom(WM_STATE), 0,
 921                              sizeof(*state)/sizeof(CARD32), False, x11drv_atom(WM_STATE),
 922                              &type, &format, &count, &remaining, (unsigned char **)&state ))
 923     {
 924         if (type == x11drv_atom(WM_STATE) && get_property_size( format, count ) >= sizeof(*state))
 925             ret = state->state;
 926         XFree( state );
 927     }
 928     wine_tsx11_unlock();
 929     return ret;
 930 }
 931
 932
 933 /***********************************************************************
 934  *           handle_wm_state_notify
 935  *
 936  * Handle a PropertyNotify for WM_STATE.
 937  */
 938 static void handle_wm_state_notify( struct x11drv_win_data *data, XPropertyEvent *event,
 939                                     BOOL update_window )
 940 {
 941     DWORD style;
 942
 943     switch(event->state)
 944     {
 945     case PropertyDelete:
 946         TRACE( "%p/%lx: WM_STATE deleted from %d\n", data->hwnd, data->whole_window, data->wm_state );
 947         data->wm_state = WithdrawnState;
 948         break;
 949     case PropertyNewValue:
 950         {
 951             int old_state = data->wm_state;
 952             int new_state = get_window_wm_state( event->display, data );
 953             if (new_state != -1 && new_state != data->wm_state)
 954             {
 955                 TRACE( "%p/%lx: new WM_STATE %d from %d\n",
 956                        data->hwnd, data->whole_window, new_state, old_state );
 957                 data->wm_state = new_state;
 958                 /* ignore the initial state transition out of withdrawn state */
 959                 /* metacity does Withdrawn->NormalState->IconicState when mapping an iconic window */
 960                 if (!old_state) return;
 961             }
 962         }
 963         break;
 964     }
 965
 966     if (!update_window || !data->managed || !data->mapped) return;
 967
 968     style = GetWindowLongW( data->hwnd, GWL_STYLE );
 969
 970     if (data->iconic && data->wm_state == NormalState)  /* restore window */
 971     {
 972         data->iconic = FALSE;
 973         if (is_net_wm_state_maximized( event->display, data ))
 974         {
 975             if ((style & WS_MAXIMIZEBOX) && !(style & WS_DISABLED))
 976             {
 977                 TRACE( "restoring to max %p/%lx\n", data->hwnd, data->whole_window );
 978                 SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
 979             }
 980             else TRACE( "not restoring to max win %p/%lx style %08x\n",
 981                         data->hwnd, data->whole_window, style );
 982         }
 983         else if (style & (WS_MINIMIZE | WS_MAXIMIZE))
 984         {
 985             TRACE( "restoring win %p/%lx\n", data->hwnd, data->whole_window );
 986             SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0 );
 987         }
 988         else TRACE( "not restoring win %p/%lx style %08x\n", data->hwnd, data->whole_window, style );
 989     }
 990     else if (!data->iconic && data->wm_state == IconicState)
 991     {
 992         data->iconic = TRUE;
 993         if ((style & WS_MINIMIZEBOX) && !(style & WS_DISABLED))
 994         {
 995             TRACE( "minimizing win %p/%lx\n", data->hwnd, data->whole_window );
 996             SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0 );
 997         }
 998         else TRACE( "not minimizing win %p/%lx style %08x\n", data->hwnd, data->whole_window, style );
 999     }
1000 }
1001
1002
1003 /***********************************************************************
1004  *           X11DRV_PropertyNotify
1005  */
1006 static void X11DRV_PropertyNotify( HWND hwnd, XEvent *xev )
1007 {
1008     XPropertyEvent *event = &xev->xproperty;
1009     struct x11drv_win_data *data;
1010
1011     if (!hwnd) return;
1012     if (!(data = X11DRV_get_win_data( hwnd ))) return;
1013
1014     if (event->atom == x11drv_atom(WM_STATE)) handle_wm_state_notify( data, event, TRUE );
1015 }
1016
1017
1018 /* event filter to wait for a WM_STATE change notification on a window */
1019 static Bool is_wm_state_notify( Display *display, XEvent *event, XPointer arg )
1020 {
1021     if (event->xany.window != (Window)arg) return 0;
1022     return (event->type == DestroyNotify ||
1023             (event->type == PropertyNotify && event->xproperty.atom == x11drv_atom(WM_STATE)));
1024 }
1025
1026 /***********************************************************************
1027  *           wait_for_withdrawn_state
1028  */
1029 void wait_for_withdrawn_state( Display *display, struct x11drv_win_data *data, BOOL set )
1030 {
1031     DWORD end = GetTickCount() + 2000;
1032
1033     if (!data->managed) return;
1034
1035     TRACE( "waiting for window %p/%lx to become %swithdrawn\n",
1036            data->hwnd, data->whole_window, set ? "" : "not " );
1037
1038     while (data->whole_window && ((data->wm_state == WithdrawnState) == !set))
1039     {
1040         XEvent event;
1041         int count = 0;
1042
1043         wine_tsx11_lock();
1044         while (XCheckIfEvent( display, &event, is_wm_state_notify, (char *)data->whole_window ))
1045         {
1046             count++;
1047             if (XFilterEvent( &event, None )) continue;  /* filtered, ignore it */
1048             if (event.type == DestroyNotify) call_event_handler( display, &event );
1049             else
1050             {
1051                 wine_tsx11_unlock();
1052                 handle_wm_state_notify( data, &event.xproperty, FALSE );
1053                 wine_tsx11_lock();
1054             }
1055         }
1056         wine_tsx11_unlock();
1057
1058         if (!count)
1059         {
1060             struct pollfd pfd;
1061             int timeout = end - GetTickCount();
1062
1063             pfd.fd = ConnectionNumber(display);
1064             pfd.events = POLLIN;
1065             if (timeout <= 0 || poll( &pfd, 1, timeout ) != 1)
1066             {
1067                 FIXME( "window %p/%lx wait timed out\n", data->hwnd, data->whole_window );
1068                 break;
1069             }
1070         }
1071     }
1072     TRACE( "window %p/%lx state now %d\n", data->hwnd, data->whole_window, data->wm_state );
1073 }
1074
1075
1076 static HWND find_drop_window( HWND hQueryWnd, LPPOINT lpPt )
1077 {
1078     RECT tempRect;
1079
1080     if (!IsWindowEnabled(hQueryWnd)) return 0;
1081
1082     GetWindowRect(hQueryWnd, &tempRect);
1083
1084     if(!PtInRect(&tempRect, *lpPt)) return 0;
1085
1086     if (!IsIconic( hQueryWnd ))
1087     {
1088         POINT pt = *lpPt;
1089         ScreenToClient( hQueryWnd, &pt );
1090         GetClientRect( hQueryWnd, &tempRect );
1091
1092         if (PtInRect( &tempRect, pt))
1093         {
1094             HWND ret = ChildWindowFromPointEx( hQueryWnd, pt, CWP_SKIPINVISIBLE|CWP_SKIPDISABLED );
1095             if (ret && ret != hQueryWnd)
1096             {
1097                 ret = find_drop_window( ret, lpPt );
1098                 if (ret) return ret;
1099             }
1100         }
1101     }
1102
1103     if(!(GetWindowLongA( hQueryWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return 0;
1104
1105     ScreenToClient(hQueryWnd, lpPt);
1106
1107     return hQueryWnd;
1108 }
1109
1110 /**********************************************************************
1111  *           EVENT_DropFromOffix
1112  *
1113  * don't know if it still works (last Changelog is from 96/11/04)
1114  */
1115 static void EVENT_DropFromOffiX( HWND hWnd, XClientMessageEvent *event )
1116 {
1117     struct x11drv_win_data *data;
1118     unsigned long       data_length;
1119     unsigned long       aux_long;
1120     unsigned char*      p_data = NULL;
1121     Atom atom_aux;
1122     int                 x, y, dummy;
1123     BOOL                bAccept;
1124     Window              win, w_aux_root, w_aux_child;
1125
1126     win = X11DRV_get_whole_window(hWnd);
1127     wine_tsx11_lock();
1128     XQueryPointer( event->display, win, &w_aux_root, &w_aux_child,
1129                    &x, &y, &dummy, &dummy, (unsigned int*)&aux_long);
1130     x += virtual_screen_rect.left;
1131     y += virtual_screen_rect.top;
1132     wine_tsx11_unlock();
1133
1134     if (!(data = X11DRV_get_win_data( hWnd ))) return;
1135
1136     /* find out drop point and drop window */
1137     if( x < 0 || y < 0 ||
1138         x > (data->whole_rect.right - data->whole_rect.left) ||
1139         y > (data->whole_rect.bottom - data->whole_rect.top) )
1140     {
1141         bAccept = GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES;
1142         x = 0;
1143         y = 0;
1144     }
1145     else
1146     {
1147         POINT   pt = { x, y };
1148         HWND    hwndDrop = find_drop_window( hWnd, &pt );
1149         if (hwndDrop)
1150         {
1151             x = pt.x;
1152             y = pt.y;
1153             bAccept = TRUE;
1154         }
1155         else
1156         {
1157             bAccept = FALSE;
1158         }
1159     }
1160
1161     if (!bAccept) return;
1162
1163     wine_tsx11_lock();
1164     XGetWindowProperty( event->display, DefaultRootWindow(event->display),
1165                         x11drv_atom(DndSelection), 0, 65535, FALSE,
1166                         AnyPropertyType, &atom_aux, &dummy,
1167                         &data_length, &aux_long, &p_data);
1168     wine_tsx11_unlock();
1169
1170     if( !aux_long && p_data)  /* don't bother if > 64K */
1171     {
1172         char *p = (char *)p_data;
1173         char *p_drop;
1174
1175         aux_long = 0;
1176         while( *p )  /* calculate buffer size */
1177         {
1178             INT len = GetShortPathNameA( p, NULL, 0 );
1179             if (len) aux_long += len + 1;
1180             p += strlen(p) + 1;
1181         }
1182         if( aux_long && aux_long < 65535 )
1183         {
1184             HDROP                 hDrop;
1185             DROPFILES *lpDrop;
1186
1187             aux_long += sizeof(DROPFILES) + 1;
1188             hDrop = GlobalAlloc( GMEM_SHARE, aux_long );
1189             lpDrop = GlobalLock( hDrop );
1190
1191             if( lpDrop )
1192             {
1193                 lpDrop->pFiles = sizeof(DROPFILES);
1194                 lpDrop->pt.x = x;
1195                 lpDrop->pt.y = y;
1196                 lpDrop->fNC = FALSE;
1197                 lpDrop->fWide = FALSE;
1198                 p_drop = (char *)(lpDrop + 1);
1199                 p = (char *)p_data;
1200                 while(*p)
1201                 {
1202                     if (GetShortPathNameA( p, p_drop, aux_long - (p_drop - (char *)lpDrop) ))
1203                         p_drop += strlen( p_drop ) + 1;
1204                     p += strlen(p) + 1;
1205                 }
1206                 *p_drop = '\0';
1207                 PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
1208             }
1209         }
1210     }
1211     wine_tsx11_lock();
1212     if( p_data ) XFree(p_data);
1213     wine_tsx11_unlock();
1214 }
1215
1216 /**********************************************************************
1217  *           EVENT_DropURLs
1218  *
1219  * drop items are separated by \n
1220  * each item is prefixed by its mime type
1221  *
1222  * event->data.l[3], event->data.l[4] contains drop x,y position
1223  */
1224 static void EVENT_DropURLs( HWND hWnd, XClientMessageEvent *event )
1225 {
1226   struct x11drv_win_data *win_data;
1227   unsigned long data_length;
1228   unsigned long aux_long, drop_len = 0;
1229   unsigned char *p_data = NULL; /* property data */
1230   char          *p_drop = NULL;
1231   char          *p, *next;
1232   int           x, y;
1233   DROPFILES *lpDrop;
1234   HDROP hDrop;
1235   union {
1236     Atom        atom_aux;
1237     int         i;
1238     Window      w_aux;
1239     unsigned int u;
1240   }             u; /* unused */
1241
1242   if (!(GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return;
1243
1244   wine_tsx11_lock();
1245   XGetWindowProperty( event->display, DefaultRootWindow(event->display),
1246                       x11drv_atom(DndSelection), 0, 65535, FALSE,
1247                       AnyPropertyType, &u.atom_aux, &u.i,
1248                       &data_length, &aux_long, &p_data);
1249   wine_tsx11_unlock();
1250   if (aux_long)
1251     WARN("property too large, truncated!\n");
1252   TRACE("urls=%s\n", p_data);
1253
1254   if( !aux_long && p_data) {    /* don't bother if > 64K */
1255     /* calculate length */
1256     p = (char*) p_data;
1257     next = strchr(p, '\n');
1258     while (p) {
1259       if (next) *next=0;
1260       if (strncmp(p,"file:",5) == 0 ) {
1261         INT len = GetShortPathNameA( p+5, NULL, 0 );
1262         if (len) drop_len += len + 1;
1263       }
1264       if (next) {
1265         *next = '\n';
1266         p = next + 1;
1267         next = strchr(p, '\n');
1268       } else {
1269         p = NULL;
1270       }
1271     }
1272
1273     if( drop_len && drop_len < 65535 ) {
1274       wine_tsx11_lock();
1275       XQueryPointer( event->display, root_window, &u.w_aux, &u.w_aux,
1276                      &x, &y, &u.i, &u.i, &u.u);
1277       x += virtual_screen_rect.left;
1278       y += virtual_screen_rect.top;
1279       wine_tsx11_unlock();
1280
1281       drop_len += sizeof(DROPFILES) + 1;
1282       hDrop = GlobalAlloc( GMEM_SHARE, drop_len );
1283       lpDrop = GlobalLock( hDrop );
1284
1285       if( lpDrop && (win_data = X11DRV_get_win_data( hWnd )))
1286       {
1287           lpDrop->pFiles = sizeof(DROPFILES);
1288           lpDrop->pt.x = x;
1289           lpDrop->pt.y = y;
1290           lpDrop->fNC =
1291             ( x < (win_data->client_rect.left - win_data->whole_rect.left)  ||
1292               y < (win_data->client_rect.top - win_data->whole_rect.top)    ||
1293               x > (win_data->client_rect.right - win_data->whole_rect.left) ||
1294               y > (win_data->client_rect.bottom - win_data->whole_rect.top) );
1295           lpDrop->fWide = FALSE;
1296           p_drop = (char*)(lpDrop + 1);
1297       }
1298
1299       /* create message content */
1300       if (p_drop) {
1301         p = (char*) p_data;
1302         next = strchr(p, '\n');
1303         while (p) {
1304           if (next) *next=0;
1305           if (strncmp(p,"file:",5) == 0 ) {
1306             INT len = GetShortPathNameA( p+5, p_drop, 65535 );
1307             if (len) {
1308               TRACE("drop file %s as %s\n", p+5, p_drop);
1309               p_drop += len+1;
1310             } else {
1311               WARN("can't convert file %s to dos name\n", p+5);
1312             }
1313           } else {
1314             WARN("unknown mime type %s\n", p);
1315           }
1316           if (next) {
1317             *next = '\n';
1318             p = next + 1;
1319             next = strchr(p, '\n');
1320           } else {
1321             p = NULL;
1322           }
1323           *p_drop = '\0';
1324         }
1325
1326         GlobalUnlock(hDrop);
1327         PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
1328       }
1329     }
1330     wine_tsx11_lock();
1331     if( p_data ) XFree(p_data);
1332     wine_tsx11_unlock();
1333   }
1334 }
1335
1336 /**********************************************************************
1337  *              handle_dnd_protocol
1338  */
1339 static void handle_dnd_protocol( HWND hwnd, XClientMessageEvent *event )
1340 {
1341     Window root, child;
1342     int root_x, root_y, child_x, child_y;
1343     unsigned int u;
1344
1345     /* query window (drag&drop event contains only drag window) */
1346     wine_tsx11_lock();
1347     XQueryPointer( event->display, root_window, &root, &child,
1348                    &root_x, &root_y, &child_x, &child_y, &u);
1349     if (XFindContext( event->display, child, winContext, (char **)&hwnd ) != 0) hwnd = 0;
1350     wine_tsx11_unlock();
1351     if (!hwnd) return;
1352     if (event->data.l[0] == DndFile || event->data.l[0] == DndFiles)
1353         EVENT_DropFromOffiX(hwnd, event);
1354     else if (event->data.l[0] == DndURL)
1355         EVENT_DropURLs(hwnd, event);
1356 }
1357
1358
1359 struct client_message_handler
1360 {
1361     int    atom;                                  /* protocol atom */
1362     void (*handler)(HWND, XClientMessageEvent *); /* corresponding handler function */
1363 };
1364
1365 static const struct client_message_handler client_messages[] =
1366 {
1367     { XATOM_WM_PROTOCOLS, handle_wm_protocols },
1368     { XATOM_DndProtocol,  handle_dnd_protocol },
1369     { XATOM_XdndEnter,    X11DRV_XDND_EnterEvent },
1370     { XATOM_XdndPosition, X11DRV_XDND_PositionEvent },
1371     { XATOM_XdndDrop,     X11DRV_XDND_DropEvent },
1372     { XATOM_XdndLeave,    X11DRV_XDND_LeaveEvent }
1373 };
1374
1375
1376 /**********************************************************************
1377  *           X11DRV_ClientMessage
1378  */
1379 static void X11DRV_ClientMessage( HWND hwnd, XEvent *xev )
1380 {
1381     XClientMessageEvent *event = &xev->xclient;
1382     unsigned int i;
1383
1384     if (!hwnd) return;
1385
1386     if (event->format != 32)
1387     {
1388         WARN( "Don't know how to handle format %d\n", event->format );
1389         return;
1390     }
1391
1392     for (i = 0; i < sizeof(client_messages)/sizeof(client_messages[0]); i++)
1393     {
1394         if (event->message_type == X11DRV_Atoms[client_messages[i].atom - FIRST_XATOM])
1395         {
1396             client_messages[i].handler( hwnd, event );
1397             return;
1398         }
1399     }
1400     TRACE( "no handler found for %ld\n", event->message_type );
1401 }
1402
1403
1404 /***********************************************************************
1405  *              X11DRV_SendInput  (X11DRV.@)
1406  */
1407 UINT CDECL X11DRV_SendInput( UINT count, LPINPUT inputs, int size )
1408 {
1409     UINT i;
1410
1411     for (i = 0; i < count; i++, inputs++)
1412     {
1413         switch(inputs->type)
1414         {
1415         case INPUT_MOUSE:
1416             X11DRV_send_mouse_input( 0, inputs->u.mi.dwFlags, inputs->u.mi.dx, inputs->u.mi.dy,
1417                                      inputs->u.mi.mouseData, inputs->u.mi.time,
1418                                      inputs->u.mi.dwExtraInfo, LLMHF_INJECTED );
1419             break;
1420         case INPUT_KEYBOARD:
1421             X11DRV_send_keyboard_input( inputs->u.ki.wVk, inputs->u.ki.wScan, inputs->u.ki.dwFlags,
1422                                         inputs->u.ki.time, inputs->u.ki.dwExtraInfo, LLKHF_INJECTED );
1423             break;
1424         case INPUT_HARDWARE:
1425             FIXME( "INPUT_HARDWARE not supported\n" );
1426             break;
1427         }
1428     }
1429     return count;
1430 }