text: /*
   * X11 event driver
   *
   * Copyright 1993 Alexandre Julliard
   *	     1999 Noel Borthwick
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
   */
  
  #include "config.h"
  
  #ifdef HAVE_POLL_H
  #include <poll.h>
  #endif
  #ifdef HAVE_SYS_POLL_H
  #include <sys/poll.h>
  #endif
  #include <X11/Xatom.h>
  #include <X11/keysym.h>
  #include <X11/Xlib.h>
  #include <X11/Xresource.h>
  #include <X11/Xutil.h>
  #ifdef HAVE_X11_EXTENSIONS_XINPUT2_H
  #include <X11/extensions/XInput2.h>
  #endif
  
  #include <assert.h>
  #include <stdarg.h>
  #include <string.h>
  
  #include "windef.h"
  #include "winbase.h"
  #include "winuser.h"
  #include "wingdi.h"
  
  #include "x11drv.h"
  
  /* avoid conflict with field names in included win32 headers */
  #undef Status
  #include "shlobj.h"  /* DROPFILES */
  #include "shellapi.h"
  
  #include "wine/server.h"
  #include "wine/debug.h"
  
  WINE_DEFAULT_DEBUG_CHANNEL(event);
  
  extern BOOL ximInComposeMode;
  
  #define DndNotDnd       -1    /* OffiX drag&drop */
  #define DndUnknown      0
  #define DndRawData      1
  #define DndFile         2
  #define DndFiles        3
  #define DndText         4
  #define DndDir          5
  #define DndLink         6
  #define DndExe          7
  
  #define DndEND          8
  
  #define DndURL          128   /* KDE drag&drop */
  
  #define XEMBED_EMBEDDED_NOTIFY        0
  #define XEMBED_WINDOW_ACTIVATE        1
  #define XEMBED_WINDOW_DEACTIVATE      2
  #define XEMBED_REQUEST_FOCUS          3
  #define XEMBED_FOCUS_IN               4
  #define XEMBED_FOCUS_OUT              5
  #define XEMBED_FOCUS_NEXT             6
  #define XEMBED_FOCUS_PREV             7
  #define XEMBED_MODALITY_ON            10
  #define XEMBED_MODALITY_OFF           11
  #define XEMBED_REGISTER_ACCELERATOR   12
  #define XEMBED_UNREGISTER_ACCELERATOR 13
  #define XEMBED_ACTIVATE_ACCELERATOR   14
  
  Bool (*pXGetEventData)( Display *display, XEvent /*XGenericEventCookie*/ *event ) = NULL;
  void (*pXFreeEventData)( Display *display, XEvent /*XGenericEventCookie*/ *event ) = NULL;
  
    /* Event handlers */
  static BOOL X11DRV_FocusIn( HWND hwnd, XEvent *event );
  static BOOL X11DRV_FocusOut( HWND hwnd, XEvent *event );
  static BOOL X11DRV_Expose( HWND hwnd, XEvent *event );
  static BOOL X11DRV_MapNotify( HWND hwnd, XEvent *event );
  static BOOL X11DRV_UnmapNotify( HWND hwnd, XEvent *event );
  static BOOL X11DRV_ReparentNotify( HWND hwnd, XEvent *event );
  static BOOL X11DRV_ConfigureNotify( HWND hwnd, XEvent *event );
  static BOOL X11DRV_PropertyNotify( HWND hwnd, XEvent *event );
  static BOOL X11DRV_ClientMessage( HWND hwnd, XEvent *event );
  static BOOL X11DRV_GravityNotify( HWND hwnd, XEvent *event );
  
  #define MAX_EVENT_HANDLERS 128
  
  static x11drv_event_handler handlers[MAX_EVENT_HANDLERS] =
  {
      NULL,                     /*  0 reserved */
      NULL,                     /*  1 reserved */
      X11DRV_KeyEvent,          /*  2 KeyPress */
      X11DRV_KeyEvent,          /*  3 KeyRelease */
      X11DRV_ButtonPress,       /*  4 ButtonPress */
      X11DRV_ButtonRelease,     /*  5 ButtonRelease */
      X11DRV_MotionNotify,      /*  6 MotionNotify */
      X11DRV_EnterNotify,       /*  7 EnterNotify */
      NULL,                     /*  8 LeaveNotify */
      X11DRV_FocusIn,           /*  9 FocusIn */
      X11DRV_FocusOut,          /* 10 FocusOut */
      X11DRV_KeymapNotify,      /* 11 KeymapNotify */
      X11DRV_Expose,            /* 12 Expose */
      NULL,                     /* 13 GraphicsExpose */
      NULL,                     /* 14 NoExpose */
      NULL,                     /* 15 VisibilityNotify */
      NULL,                     /* 16 CreateNotify */
      X11DRV_DestroyNotify,     /* 17 DestroyNotify */
      X11DRV_UnmapNotify,       /* 18 UnmapNotify */
      X11DRV_MapNotify,         /* 19 MapNotify */
      NULL,                     /* 20 MapRequest */
      X11DRV_ReparentNotify,    /* 21 ReparentNotify */
      X11DRV_ConfigureNotify,   /* 22 ConfigureNotify */
      NULL,                     /* 23 ConfigureRequest */
      X11DRV_GravityNotify,     /* 24 GravityNotify */
      NULL,                     /* 25 ResizeRequest */
      NULL,                     /* 26 CirculateNotify */
      NULL,                     /* 27 CirculateRequest */
      X11DRV_PropertyNotify,    /* 28 PropertyNotify */
      X11DRV_SelectionClear,    /* 29 SelectionClear */
      X11DRV_SelectionRequest,  /* 30 SelectionRequest */
      NULL,                     /* 31 SelectionNotify */
      NULL,                     /* 32 ColormapNotify */
      X11DRV_ClientMessage,     /* 33 ClientMessage */
      X11DRV_MappingNotify,     /* 34 MappingNotify */
      X11DRV_GenericEvent       /* 35 GenericEvent */
  };
  
  static const char * event_names[MAX_EVENT_HANDLERS] =
  {
      NULL, NULL, "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease",
      "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut",
      "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify",
      "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",
      "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify", "ResizeRequest",
      "CirculateNotify", "CirculateRequest", "PropertyNotify", "SelectionClear", "SelectionRequest",
      "SelectionNotify", "ColormapNotify", "ClientMessage", "MappingNotify", "GenericEvent"
  };
  
  int xinput2_opcode = 0;
  
  /* return the name of an X event */
  static const char *dbgstr_event( int type )
  {
      if (type < MAX_EVENT_HANDLERS && event_names[type]) return event_names[type];
      return wine_dbg_sprintf( "Unknown event %d", type );
  }
  
  static inline void get_event_data( XEvent *event )
  {
  #if defined(GenericEvent) && defined(HAVE_XEVENT_XCOOKIE)
      if (event->xany.type != GenericEvent) return;
      if (!pXGetEventData || !pXGetEventData( event->xany.display, event )) event->xcookie.data = NULL;
  #endif
  }
  
  static inline void free_event_data( XEvent *event )
  {
  #if defined(GenericEvent) && defined(HAVE_XEVENT_XCOOKIE)
      if (event->xany.type != GenericEvent) return;
      if (event->xcookie.data) pXFreeEventData( event->xany.display, event );
  #endif
  }
  
  /***********************************************************************
   *           xembed_request_focus
   */
  static void xembed_request_focus( Display *display, Window window, DWORD timestamp )
  {
      XEvent xev;
  
      xev.xclient.type = ClientMessage;
      xev.xclient.window = window;
      xev.xclient.message_type = x11drv_atom(_XEMBED);
      xev.xclient.serial = 0;
      xev.xclient.display = display;
      xev.xclient.send_event = True;
      xev.xclient.format = 32;
  
      xev.xclient.data.l[0] = timestamp;
      xev.xclient.data.l[1] = XEMBED_REQUEST_FOCUS;
      xev.xclient.data.l[2] = 0;
      xev.xclient.data.l[3] = 0;
      xev.xclient.data.l[4] = 0;
  
      XSendEvent(display, window, False, NoEventMask, &xev);
      XFlush( display );
  }
  
  /***********************************************************************
   *           X11DRV_register_event_handler
   *
   * Register a handler for a given event type.
   * If already registered, overwrite the previous handler.
   */
  void X11DRV_register_event_handler( int type, x11drv_event_handler handler, const char *name )
  {
      assert( type < MAX_EVENT_HANDLERS );
      assert( !handlers[type] || handlers[type] == handler );
      handlers[type] = handler;
      event_names[type] = name;
      TRACE("registered handler %p for event %d %s\n", handler, type, debugstr_a(name) );
  }
  
  
  /***********************************************************************
   *           filter_event
   */
  static Bool filter_event( Display *display, XEvent *event, char *arg )
  {
      ULONG_PTR mask = (ULONG_PTR)arg;
  
      if ((mask & QS_ALLINPUT) == QS_ALLINPUT) return 1;
  
      switch(event->type)
      {
      case KeyPress:
      case KeyRelease:
      case KeymapNotify:
      case MappingNotify:
          return (mask & (QS_KEY|QS_HOTKEY)) != 0;
      case ButtonPress:
      case ButtonRelease:
          return (mask & QS_MOUSEBUTTON) != 0;
  #ifdef GenericEvent
      case GenericEvent:
  #endif
      case MotionNotify:
      case EnterNotify:
      case LeaveNotify:
          return (mask & QS_MOUSEMOVE) != 0;
      case Expose:
          return (mask & QS_PAINT) != 0;
      case FocusIn:
      case FocusOut:
      case MapNotify:
      case UnmapNotify:
      case ConfigureNotify:
      case PropertyNotify:
      case ClientMessage:
          return (mask & QS_POSTMESSAGE) != 0;
      default:
          return (mask & QS_SENDMESSAGE) != 0;
      }
  }
  
  
  enum event_merge_action
  {
      MERGE_DISCARD,  /* discard the old event */
      MERGE_HANDLE,   /* handle the old event */
      MERGE_KEEP,     /* keep the old event for future merging */
      MERGE_IGNORE    /* ignore the new event, keep the old one */
  };
  
  /***********************************************************************
   *           merge_raw_motion_events
   */
  #ifdef HAVE_X11_EXTENSIONS_XINPUT2_H
  static enum event_merge_action merge_raw_motion_events( XIRawEvent *prev, XIRawEvent *next )
  {
      int i, j, k;
      unsigned char mask;
  
      if (!prev->valuators.mask_len) return MERGE_HANDLE;
      if (!next->valuators.mask_len) return MERGE_HANDLE;
  
      mask = prev->valuators.mask[0] | next->valuators.mask[0];
      if (mask == next->valuators.mask[0])  /* keep next */
      {
          for (i = j = k = 0; i < 8; i++)
          {
              if (XIMaskIsSet( prev->valuators.mask, i ))
                  next->valuators.values[j] += prev->valuators.values[k++];
              if (XIMaskIsSet( next->valuators.mask, i )) j++;
          }
          TRACE( "merging duplicate GenericEvent\n" );
          return MERGE_DISCARD;
      }
      if (mask == prev->valuators.mask[0])  /* keep prev */
      {
          for (i = j = k = 0; i < 8; i++)
          {
              if (XIMaskIsSet( next->valuators.mask, i ))
                  prev->valuators.values[j] += next->valuators.values[k++];
              if (XIMaskIsSet( prev->valuators.mask, i )) j++;
          }
          TRACE( "merging duplicate GenericEvent\n" );
          return MERGE_IGNORE;
      }
      /* can't merge events with disjoint masks */
      return MERGE_HANDLE;
  }
  #endif
  
  /***********************************************************************
   *           merge_events
   *
   * Try to merge 2 consecutive events.
   */
  static enum event_merge_action merge_events( XEvent *prev, XEvent *next )
  {
      switch (prev->type)
      {
      case ConfigureNotify:
          switch (next->type)
          {
          case ConfigureNotify:
              if (prev->xany.window == next->xany.window)
              {
                  TRACE( "discarding duplicate ConfigureNotify for window %lx\n", prev->xany.window );
                  return MERGE_DISCARD;
              }
              break;
          case Expose:
          case PropertyNotify:
              return MERGE_KEEP;
          }
          break;
      case MotionNotify:
          switch (next->type)
          {
          case MotionNotify:
              if (prev->xany.window == next->xany.window)
              {
                  TRACE( "discarding duplicate MotionNotify for window %lx\n", prev->xany.window );
                  return MERGE_DISCARD;
              }
              break;
  #ifdef HAVE_X11_EXTENSIONS_XINPUT2_H
          case GenericEvent:
              if (next->xcookie.extension != xinput2_opcode) break;
              if (next->xcookie.evtype != XI_RawMotion) break;
              if (x11drv_thread_data()->warp_serial) break;
              return MERGE_KEEP;
          }
          break;
      case GenericEvent:
          if (prev->xcookie.extension != xinput2_opcode) break;
          if (prev->xcookie.evtype != XI_RawMotion) break;
          switch (next->type)
          {
          case GenericEvent:
              if (next->xcookie.extension != xinput2_opcode) break;
              if (next->xcookie.evtype != XI_RawMotion) break;
              if (x11drv_thread_data()->warp_serial) break;
              return merge_raw_motion_events( prev->xcookie.data, next->xcookie.data );
  #endif
          }
          break;
      }
      return MERGE_HANDLE;
  }
  
  
  /***********************************************************************
   *           call_event_handler
   */
  static inline BOOL call_event_handler( Display *display, XEvent *event )
  {
      HWND hwnd;
      XEvent *prev;
      struct x11drv_thread_data *thread_data;
      BOOL ret;
  
      if (!handlers[event->type])
      {
          TRACE( "%s for win %lx, ignoring\n", dbgstr_event( event->type ), event->xany.window );
          return FALSE;  /* no handler, ignore it */
      }
  
      if (XFindContext( display, event->xany.window, winContext, (char **)&hwnd ) != 0)
          hwnd = 0;  /* not for a registered window */
      if (!hwnd && event->xany.window == root_window) hwnd = GetDesktopWindow();
  
      TRACE( "%lu %s for hwnd/window %p/%lx\n",
             event->xany.serial, dbgstr_event( event->type ), hwnd, event->xany.window );
      thread_data = x11drv_thread_data();
      prev = thread_data->current_event;
      thread_data->current_event = event;
      ret = handlers[event->type]( hwnd, event );
      thread_data->current_event = prev;
      return ret;
  }
  
  
  /***********************************************************************
   *           process_events
   */
  static BOOL process_events( Display *display, Bool (*filter)(Display*, XEvent*,XPointer), ULONG_PTR arg )
  {
      XEvent event, prev_event;
      int count = 0;
      BOOL queued = FALSE;
      enum event_merge_action action = MERGE_DISCARD;
  
      prev_event.type = 0;
      while (XCheckIfEvent( display, &event, filter, (char *)arg ))
      {
          count++;
          if (XFilterEvent( &event, None ))
          {
              /*
               * SCIM on linux filters key events strangely. It does not filter the
               * KeyPress events for these keys however it does filter the
               * KeyRelease events. This causes wine to become very confused as
               * to the keyboard state.
               *
               * We need to let those KeyRelease events be processed so that the
               * keyboard state is correct.
               */
              if (event.type == KeyRelease)
              {
                  KeySym keysym = 0;
                  XKeyEvent *keyevent = &event.xkey;
  
                  XLookupString(keyevent, NULL, 0, &keysym, NULL);
                  if (!(keysym == XK_Shift_L ||
                      keysym == XK_Shift_R ||
                      keysym == XK_Control_L ||
                      keysym == XK_Control_R ||
                      keysym == XK_Alt_R ||
                      keysym == XK_Alt_L ||
                      keysym == XK_Meta_R ||
                      keysym == XK_Meta_L))
                          continue; /* not a key we care about, ignore it */
              }
              else
                  continue;  /* filtered, ignore it */
          }
          get_event_data( &event );
          if (prev_event.type) action = merge_events( &prev_event, &event );
          switch( action )
          {
          case MERGE_HANDLE:  /* handle prev, keep new */
              queued |= call_event_handler( display, &prev_event );
              /* fall through */
          case MERGE_DISCARD:  /* discard prev, keep new */
              free_event_data( &prev_event );
              prev_event = event;
              break;
          case MERGE_KEEP:  /* handle new, keep prev for future merging */
              queued |= call_event_handler( display, &event );
              /* fall through */
          case MERGE_IGNORE: /* ignore new, keep prev for future merging */
              free_event_data( &event );
              break;
          }
      }
      if (prev_event.type) queued |= call_event_handler( display, &prev_event );
      free_event_data( &prev_event );
      XFlush( gdi_display );
      if (count) TRACE( "processed %d events, returning %d\n", count, queued );
      return queued;
  }
  
  
  /***********************************************************************
   *           MsgWaitForMultipleObjectsEx   (X11DRV.@)
   */
  DWORD CDECL X11DRV_MsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
                                                  DWORD timeout, DWORD mask, DWORD flags )
  {
      DWORD ret;
      struct x11drv_thread_data *data = TlsGetValue( thread_data_tls_index );
  
      if (!data)
      {
          if (!count && !timeout) return WAIT_TIMEOUT;
          return WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
                                           timeout, flags & MWMO_ALERTABLE );
      }
  
      if (data->current_event) mask = 0;  /* don't process nested events */
  
      if (process_events( data->display, filter_event, mask )) ret = count - 1;
      else if (count || timeout)
      {
          ret = WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
                                          timeout, flags & MWMO_ALERTABLE );
          if (ret == count - 1) process_events( data->display, filter_event, mask );
      }
      else ret = WAIT_TIMEOUT;
  
      return ret;
  }
  
  /***********************************************************************
   *           EVENT_x11_time_to_win32_time
   *
   * Make our timer and the X timer line up as best we can
   *  Pass 0 to retrieve the current adjustment value (times -1)
   */
  DWORD EVENT_x11_time_to_win32_time(Time time)
  {
    static DWORD adjust = 0;
    DWORD now = GetTickCount();
    DWORD ret;
  
    if (! adjust && time != 0)
    {
      ret = now;
      adjust = time - now;
    }
    else
    {
        /* If we got an event in the 'future', then our clock is clearly wrong. 
           If we got it more than 10000 ms in the future, then it's most likely
           that the clock has wrapped.  */
  
        ret = time - adjust;
        if (ret > now && ((ret - now) < 10000) && time != 0)
        {
          adjust += ret - now;
          ret    -= ret - now;
        }
    }
  
    return ret;
  
  }
  
  /*******************************************************************
   *         can_activate_window
   *
   * Check if we can activate the specified window.
   */
  static inline BOOL can_activate_window( HWND hwnd )
  {
      LONG style = GetWindowLongW( hwnd, GWL_STYLE );
      RECT rect;
  
      if (!(style & WS_VISIBLE)) return FALSE;
      if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return FALSE;
      if (style & WS_MINIMIZE) return FALSE;
      if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOACTIVATE) return FALSE;
      if (hwnd == GetDesktopWindow()) return FALSE;
      if (GetWindowRect( hwnd, &rect ) && IsRectEmpty( &rect )) return FALSE;
      return !(style & WS_DISABLED);
  }
  
  
  /**********************************************************************
   *              set_input_focus
   *
   * Try to force focus for embedded or non-managed windows.
   */
  static void set_input_focus( struct x11drv_win_data *data )
  {
      XWindowChanges changes;
      DWORD timestamp;
  
      if (!data->whole_window) return;
  
      if (EVENT_x11_time_to_win32_time(0))
          /* ICCCM says don't use CurrentTime, so try to use last message time if possible */
          /* FIXME: this is not entirely correct */
          timestamp = GetMessageTime() - EVENT_x11_time_to_win32_time(0);
      else
          timestamp = CurrentTime;
  
      /* Set X focus and install colormap */
      changes.stack_mode = Above;
      XConfigureWindow( data->display, data->whole_window, CWStackMode, &changes );
  
      if (data->embedder)
          xembed_request_focus( data->display, data->embedder, timestamp );
      else
          XSetInputFocus( data->display, data->whole_window, RevertToParent, timestamp );
  
  }
  
  /**********************************************************************
   *              set_focus
   */
  static void set_focus( Display *display, HWND hwnd, Time time )
  {
      HWND focus;
      Window win;
      GUITHREADINFO threadinfo;
  
      TRACE( "setting foreground window to %p\n", hwnd );
      SetForegroundWindow( hwnd );
  
      threadinfo.cbSize = sizeof(threadinfo);
      GetGUIThreadInfo(0, &threadinfo);
      focus = threadinfo.hwndFocus;
      if (!focus) focus = threadinfo.hwndActive;
      if (focus) focus = GetAncestor( focus, GA_ROOT );
      win = X11DRV_get_whole_window(focus);
  
      if (win)
      {
          TRACE( "setting focus to %p (%lx) time=%ld\n", focus, win, time );
          XSetInputFocus( display, win, RevertToParent, time );
      }
  }
  
  
  /**********************************************************************
   *              handle_manager_message
   */
  static void handle_manager_message( HWND hwnd, XClientMessageEvent *event )
  {
      if (hwnd != GetDesktopWindow()) return;
      if (systray_atom && event->data.l[1] == systray_atom)
          change_systray_owner( event->display, event->data.l[2] );
  }
  
  
  /**********************************************************************
   *              handle_wm_protocols
   */
  static void handle_wm_protocols( HWND hwnd, XClientMessageEvent *event )
  {
      Atom protocol = (Atom)event->data.l[0];
      Time event_time = (Time)event->data.l[1];
  
      if (!protocol) return;
  
      if (protocol == x11drv_atom(WM_DELETE_WINDOW))
      {
          update_user_time( event_time );
  
          if (hwnd == GetDesktopWindow())
          {
              /* The desktop window does not have a close button that we can
               * pretend to click. Therefore, we simply send it a close command. */
              SendMessageW(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0);
              return;
          }
  
          /* Ignore the delete window request if the window has been disabled
           * and we are in managed mode. This is to disallow applications from
           * being closed by the window manager while in a modal state.
           */
          if (IsWindowEnabled(hwnd))
          {
              HMENU hSysMenu;
  
              if (GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE) return;
              hSysMenu = GetSystemMenu(hwnd, FALSE);
              if (hSysMenu)
              {
                  UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
                  if (state == 0xFFFFFFFF || (state & (MF_DISABLED | MF_GRAYED)))
                      return;
              }
              if (GetActiveWindow() != hwnd)
              {
                  LRESULT ma = SendMessageW( hwnd, WM_MOUSEACTIVATE,
                                             (WPARAM)GetAncestor( hwnd, GA_ROOT ),
                                             MAKELPARAM( HTCLOSE, WM_NCLBUTTONDOWN ) );
                  switch(ma)
                  {
                      case MA_NOACTIVATEANDEAT:
                      case MA_ACTIVATEANDEAT:
                          return;
                      case MA_NOACTIVATE:
                          break;
                      case MA_ACTIVATE:
                      case 0:
                          SetActiveWindow(hwnd);
                          break;
                      default:
                          WARN( "unknown WM_MOUSEACTIVATE code %d\n", (int) ma );
                          break;
                  }
              }
  
              PostMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, 0 );
          }
      }
      else if (protocol == x11drv_atom(WM_TAKE_FOCUS))
      {
          HWND last_focus = x11drv_thread_data()->last_focus;
  
          TRACE( "got take focus msg for %p, enabled=%d, visible=%d (style %08x), focus=%p, active=%p, fg=%p, last=%p\n",
                 hwnd, IsWindowEnabled(hwnd), IsWindowVisible(hwnd), GetWindowLongW(hwnd, GWL_STYLE),
                 GetFocus(), GetActiveWindow(), GetForegroundWindow(), last_focus );
  
          if (can_activate_window(hwnd))
          {
              /* simulate a mouse click on the caption to find out
               * whether the window wants to be activated */
              LRESULT ma = SendMessageW( hwnd, WM_MOUSEACTIVATE,
                                         (WPARAM)GetAncestor( hwnd, GA_ROOT ),
                                         MAKELONG(HTCAPTION,WM_LBUTTONDOWN) );
              if (ma != MA_NOACTIVATEANDEAT && ma != MA_NOACTIVATE)
              {
                  set_focus( event->display, hwnd, event_time );
                  return;
              }
          }
          else if (hwnd == GetDesktopWindow())
          {
              hwnd = GetForegroundWindow();
              if (!hwnd) hwnd = last_focus;
              if (!hwnd) hwnd = GetDesktopWindow();
              set_focus( event->display, hwnd, event_time );
              return;
          }
          /* try to find some other window to give the focus to */
          hwnd = GetFocus();
          if (hwnd) hwnd = GetAncestor( hwnd, GA_ROOT );
          if (!hwnd) hwnd = GetActiveWindow();
          if (!hwnd) hwnd = last_focus;
          if (hwnd && can_activate_window(hwnd)) set_focus( event->display, hwnd, event_time );
      }
      else if (protocol == x11drv_atom(_NET_WM_PING))
      {
        XClientMessageEvent xev;
        xev = *event;
        
        TRACE("NET_WM Ping\n");
        xev.window = DefaultRootWindow(xev.display);
        XSendEvent(xev.display, xev.window, False, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent*)&xev);
      }
  }
  
  
  static const char * const focus_details[] =
  {
      "NotifyAncestor",
      "NotifyVirtual",
      "NotifyInferior",
      "NotifyNonlinear",
      "NotifyNonlinearVirtual",
      "NotifyPointer",
      "NotifyPointerRoot",
      "NotifyDetailNone"
  };
  
  /**********************************************************************
   *              X11DRV_FocusIn
   */
  static BOOL X11DRV_FocusIn( HWND hwnd, XEvent *xev )
  {
      XFocusChangeEvent *event = &xev->xfocus;
      XIC xic;
  
      if (!hwnd) return FALSE;
  
      TRACE( "win %p xwin %lx detail=%s\n", hwnd, event->window, focus_details[event->detail] );
  
      if (event->detail == NotifyPointer) return FALSE;
      if (hwnd == GetDesktopWindow()) return FALSE;
  
      if ((xic = X11DRV_get_ic( hwnd ))) XSetICFocus( xic );
      if (use_take_focus)
      {
          if (hwnd == GetForegroundWindow()) clip_fullscreen_window( hwnd, FALSE );
          return TRUE;
      }
  
      if (!can_activate_window(hwnd))
      {
          HWND hwnd = GetFocus();
          if (hwnd) hwnd = GetAncestor( hwnd, GA_ROOT );
          if (!hwnd) hwnd = GetActiveWindow();
          if (!hwnd) hwnd = x11drv_thread_data()->last_focus;
          if (hwnd && can_activate_window(hwnd)) set_focus( event->display, hwnd, CurrentTime );
      }
      else SetForegroundWindow( hwnd );
      return TRUE;
  }
  
  /**********************************************************************
   *              focus_out
   */
   static void focus_out( Display *display , HWND hwnd )
   {
      HWND hwnd_tmp;
      Window focus_win;
      int revert;
      XIC xic;
      struct x11drv_win_data *data;
  
      if (ximInComposeMode) return;
  
      data = get_win_data(hwnd);
      if(data){
          ULONGLONG now = GetTickCount64();
          if(data->take_focus_back > 0 &&
                  now >= data->take_focus_back &&
                  now - data->take_focus_back < 1000){
              data->take_focus_back = 0;
              TRACE("workaround mutter bug, taking focus back\n");
              XSetInputFocus( data->display, data->whole_window, RevertToParent, CurrentTime);
              release_win_data(data);
              /* don't inform win32 client */
              return;
          }
          data->take_focus_back = 0;
          release_win_data(data);
      }
  
      x11drv_thread_data()->last_focus = hwnd;
      if ((xic = X11DRV_get_ic( hwnd ))) XUnsetICFocus( xic );
  
      if (root_window != DefaultRootWindow(display))
      {
          if (hwnd == GetDesktopWindow()) reset_clipping_window();
          return;
      }
      if (hwnd != GetForegroundWindow()) return;
      SendMessageW( hwnd, WM_CANCELMODE, 0, 0 );
  
      /* don't reset the foreground window, if the window which is
         getting the focus is a Wine window */
  
      XGetInputFocus( display, &focus_win, &revert );
      if (focus_win)
      {
          if (XFindContext( display, focus_win, winContext, (char **)&hwnd_tmp ) != 0)
              focus_win = 0;
      }
  
      if (!focus_win)
      {
          /* Abey : 6-Oct-99. Check again if the focus out window is the
             Foreground window, because in most cases the messages sent
             above must have already changed the foreground window, in which
             case we don't have to change the foreground window to 0 */
          if (hwnd == GetForegroundWindow())
          {
              TRACE( "lost focus, setting fg to desktop\n" );
              SetForegroundWindow( GetDesktopWindow() );
          }
      }
   }
  
  /**********************************************************************
   *              X11DRV_FocusOut
   *
   * Note: only top-level windows get FocusOut events.
   */
  static BOOL X11DRV_FocusOut( HWND hwnd, XEvent *xev )
  {
      XFocusChangeEvent *event = &xev->xfocus;
  
      TRACE( "win %p xwin %lx detail=%s\n", hwnd, event->window, focus_details[event->detail] );
  
      if (event->detail == NotifyPointer)
      {
          if (!hwnd && event->window == x11drv_thread_data()->clip_window) reset_clipping_window();
          return TRUE;
      }
      if (!hwnd) return FALSE;
      focus_out( event->display, hwnd );
      return TRUE;
  }
  
  
  /***********************************************************************
   *           X11DRV_Expose
   */
  static BOOL X11DRV_Expose( HWND hwnd, XEvent *xev )
  {
      XExposeEvent *event = &xev->xexpose;
      RECT rect;
      POINT pos;
      struct x11drv_win_data *data;
      HRGN surface_region = 0;
      UINT flags = RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN;
  
      TRACE( "win %p (%lx) %d,%d %dx%d\n",
             hwnd, event->window, event->x, event->y, event->width, event->height );
  
      if (event->window != root_window)
      {
          pos.x = event->x;
          pos.y = event->y;
      }
      else pos = root_to_virtual_screen( event->x, event->y );
  
      if (!(data = get_win_data( hwnd ))) return FALSE;
  
      rect.left   = pos.x;
      rect.top    = pos.y;
      rect.right  = pos.x + event->width;
      rect.bottom = pos.y + event->height;
  
      if (event->window != data->client_window)
      {
          if (data->surface)
          {
              surface_region = expose_surface( data->surface, &rect );
              if (!surface_region) flags = 0;
              else OffsetRgn( surface_region, data->whole_rect.left - data->client_rect.left,
                              data->whole_rect.top - data->client_rect.top );
  
              if (data->vis.visualid != default_visual.visualid)
                  data->surface->funcs->flush( data->surface );
          }
          OffsetRect( &rect, data->whole_rect.left - data->client_rect.left,
                      data->whole_rect.top - data->client_rect.top );
      }
  
      if (event->window != root_window)
      {
          if (GetWindowLongW( data->hwnd, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL)
              mirror_rect( &data->client_rect, &rect );
  
          SERVER_START_REQ( update_window_zorder )
          {
              req->window      = wine_server_user_handle( hwnd );
              req->rect.left   = rect.left;
              req->rect.top    = rect.top;
              req->rect.right  = rect.right;
              req->rect.bottom = rect.bottom;
              wine_server_call( req );
          }
          SERVER_END_REQ;
      }
      else flags &= ~RDW_ALLCHILDREN;
  
      release_win_data( data );
  
      if (flags) RedrawWindow( hwnd, &rect, surface_region, flags );
      if (surface_region) DeleteObject( surface_region );
      return TRUE;
  }
  
  
  /**********************************************************************
   *		X11DRV_MapNotify
   */
  static BOOL X11DRV_MapNotify( HWND hwnd, XEvent *event )
  {
      struct x11drv_win_data *data;
  
      if (event->xany.window == x11drv_thread_data()->clip_window)
      {
          clipping_cursor = TRUE;
          return TRUE;
      }
      if (!(data = get_win_data( hwnd ))) return FALSE;
  
      if (!data->managed && !data->embedded && data->mapped)
      {
          HWND hwndFocus = GetFocus();
          if (hwndFocus && IsChild( hwnd, hwndFocus ))
              set_input_focus( data );
      }
      release_win_data( data );
      return TRUE;
  }
  
  
  /**********************************************************************
   *		X11DRV_UnmapNotify
   */
  static BOOL X11DRV_UnmapNotify( HWND hwnd, XEvent *event )
  {
      if (event->xany.window == x11drv_thread_data()->clip_window)
          clipping_cursor = FALSE;
      return TRUE;
  }
  
  
  /***********************************************************************
   *           reparent_notify
   */
  static void reparent_notify( Display *display, HWND hwnd, Window xparent, int x, int y )
  {
      HWND parent, old_parent;
      DWORD style;
  
      style = GetWindowLongW( hwnd, GWL_STYLE );
      if (xparent == root_window)
      {
          parent = GetDesktopWindow();
          style = (style & ~WS_CHILD) | WS_POPUP;
      }
      else
      {
          if (!(parent = create_foreign_window( display, xparent ))) return;
          style = (style & ~WS_POPUP) | WS_CHILD;
      }
  
      ShowWindow( hwnd, SW_HIDE );
      old_parent = SetParent( hwnd, parent );
      SetWindowLongW( hwnd, GWL_STYLE, style );
      SetWindowPos( hwnd, HWND_TOP, x, y, 0, 0,
                    SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOCOPYBITS |
                    ((style & WS_VISIBLE) ? SWP_SHOWWINDOW : 0) );
  
      /* make old parent destroy itself if it no longer has children */
      if (old_parent != GetDesktopWindow()) PostMessageW( old_parent, WM_CLOSE, 0, 0 );
  }
  
  
  /***********************************************************************
   *           X11DRV_ReparentNotify
   */
  static BOOL X11DRV_ReparentNotify( HWND hwnd, XEvent *xev )
  {
      XReparentEvent *event = &xev->xreparent;
      struct x11drv_win_data *data;
  
      if (!(data = get_win_data( hwnd ))) return FALSE;
  
      if (!data->embedded)
      {
          release_win_data( data );
          return FALSE;
      }
  
      if (data->whole_window)
      {
          if (event->parent == root_window)
          {
              TRACE( "%p/%lx reparented to root\n", hwnd, data->whole_window );
              data->embedder = 0;
              release_win_data( data );
              SendMessageW( hwnd, WM_CLOSE, 0, 0 );
              return TRUE;
          }
          data->embedder = event->parent;
      }
  
      TRACE( "%p/%lx reparented to %lx\n", hwnd, data->whole_window, event->parent );
      release_win_data( data );
  
      reparent_notify( event->display, hwnd, event->parent, event->x, event->y );
      return TRUE;
  }
  
  
  /***********************************************************************
   *		X11DRV_ConfigureNotify
   */
  static BOOL X11DRV_ConfigureNotify( HWND hwnd, XEvent *xev )
  {
      XConfigureEvent *event = &xev->xconfigure;
      struct x11drv_win_data *data;
      RECT rect;
      POINT pos;
      UINT flags;
      HWND parent;
      BOOL root_coords;
      int cx, cy, x = event->x, y = event->y;
      DWORD style;
  
      if (!hwnd) return FALSE;
      if (!(data = get_win_data( hwnd ))) return FALSE;
      if (!data->mapped || data->iconic) goto done;
      if (data->whole_window && !data->managed) goto done;
      /* ignore synthetic events on foreign windows */
      if (event->send_event && !data->whole_window) goto done;
      if (data->configure_serial && (long)(data->configure_serial - event->serial) > 0)
      {
          TRACE( "win %p/%lx event %d,%d,%dx%d ignoring old serial %lu/%lu\n",
                 hwnd, data->whole_window, event->x, event->y, event->width, event->height,
                 event->serial, data->configure_serial );
          goto done;
      }
  
      /* Get geometry */
  
      parent = GetAncestor( hwnd, GA_PARENT );
      root_coords = event->send_event;  /* synthetic events are always in root coords */
  
      if (!root_coords && parent == GetDesktopWindow()) /* normal event, map coordinates to the root */
      {
          Window child;
          XTranslateCoordinates( event->display, event->window, root_window,
                                 0, 0, &x, &y, &child );
          root_coords = TRUE;
      }
  
      if (!root_coords)
      {
          pos.x = x;
          pos.y = y;
      }
      else pos = root_to_virtual_screen( x, y );
  
      if(data->fs_hack){
          POINT p = fs_hack_current_mode();
          rect.left = 0;
          rect.top = 0;
          rect.right = p.x;
          rect.bottom = p.y;
      }else{
          rect.left   = pos.x;
          rect.top    = pos.y;
          rect.right  = pos.x + event->width;
          rect.bottom = pos.y + event->height;
      }
      TRACE( "win %p/%lx new X rect %d,%d,%dx%d (event %d,%d,%dx%d)\n",
             hwnd, data->whole_window, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
             event->x, event->y, event->width, event->height );
  
      X11DRV_X_to_window_rect( data, &rect );
      if (root_coords) MapWindowPoints( 0, parent, (POINT *)&rect, 2 );
  
      /* Compare what has changed */
  
      x     = rect.left;
      y     = rect.top;
      cx    = rect.right - rect.left;
      cy    = rect.bottom - rect.top;
      flags = SWP_NOACTIVATE | SWP_NOZORDER;
  
      if (!data->whole_window) flags |= SWP_NOCOPYBITS;  /* we can't copy bits of foreign windows */
  
      if (data->window_rect.left == x && data->window_rect.top == y) flags |= SWP_NOMOVE;
      else
          TRACE( "%p moving from (%d,%d) to (%d,%d)\n",
                 hwnd, data->window_rect.left, data->window_rect.top, x, y );
  
      if ((data->window_rect.right - data->window_rect.left == cx &&
           data->window_rect.bottom - data->window_rect.top == cy) ||
          IsRectEmpty( &data->window_rect ))
          flags |= SWP_NOSIZE;
      else
          TRACE( "%p resizing from (%dx%d) to (%dx%d)\n",
                 hwnd, data->window_rect.right - data->window_rect.left,
                 data->window_rect.bottom - data->window_rect.top, cx, cy );
  
      style = GetWindowLongW( data->hwnd, GWL_STYLE );
      if ((style & WS_CAPTION) == WS_CAPTION)
      {
          read_net_wm_states( event->display, data );
          if ((data->net_wm_state & (1 << NET_WM_STATE_MAXIMIZED)))
          {
              if (!(style & WS_MAXIMIZE))
              {
                  TRACE( "win %p/%lx is maximized\n", data->hwnd, data->whole_window );
                  release_win_data( data );
                  SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
                  return TRUE;
              }
          }
          else if (style & WS_MAXIMIZE)
          {
              TRACE( "window %p/%lx is no longer maximized\n", data->hwnd, data->whole_window );
              release_win_data( data );
              SendMessageW( data->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0 );
              return TRUE;
          }
      }
  
      if ((flags & (SWP_NOSIZE | SWP_NOMOVE)) != (SWP_NOSIZE | SWP_NOMOVE))
      {
          release_win_data( data );
          SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
          return TRUE;
      }
  
  done:
      release_win_data( data );
      return FALSE;
  }
  
  
  /**********************************************************************
   *           X11DRV_GravityNotify
   */
  static BOOL X11DRV_GravityNotify( HWND hwnd, XEvent *xev )
  {
      XGravityEvent *event = &xev->xgravity;
      struct x11drv_win_data *data = get_win_data( hwnd );
      RECT rect, window_rect;
  
      if (!data) return FALSE;
  
      if (data->whole_window)  /* only handle this for foreign windows */
      {
          release_win_data( data );
          return FALSE;
      }
  
      rect.left   = event->x;
      rect.top    = event->y;
      rect.right  = rect.left + data->whole_rect.right - data->whole_rect.left;
      rect.bottom = rect.top + data->whole_rect.bottom - data->whole_rect.top;
  
      TRACE( "win %p/%lx new X rect %d,%d,%dx%d (event %d,%d)\n",
             hwnd, data->whole_window, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
             event->x, event->y );
  
      X11DRV_X_to_window_rect( data, &rect );
      window_rect = data->window_rect;
      release_win_data( data );
  
      if (window_rect.left != rect.left || window_rect.top != rect.top)
          SetWindowPos( hwnd, 0, rect.left, rect.top, 0, 0,
                        SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOCOPYBITS );
      return TRUE;
  }
  
  
  /***********************************************************************
   *           get_window_wm_state
   */
  static int get_window_wm_state( Display *display, Window window )
  {
      struct
      {
          CARD32 state;
          XID     icon;
      } *state;
      Atom type;
      int format, ret = -1;
      unsigned long count, remaining;
  
      if (!XGetWindowProperty( display, window, x11drv_atom(WM_STATE), 0,
                               sizeof(*state)/sizeof(CARD32), False, x11drv_atom(WM_STATE),
                               &type, &format, &count, &remaining, (unsigned char **)&state ))
      {
          if (type == x11drv_atom(WM_STATE) && get_property_size( format, count ) >= sizeof(*state))
              ret = state->state;
          XFree( state );
      }
      return ret;
  }
  
  
  /***********************************************************************
   *           handle_wm_state_notify
   *
   * Handle a PropertyNotify for WM_STATE.
   */
  static void handle_wm_state_notify( HWND hwnd, XPropertyEvent *event, BOOL update_window )
  {
      struct x11drv_win_data *data = get_win_data( hwnd );
      DWORD style;
  
      if (!data) return;
  
      switch(event->state)
      {
      case PropertyDelete:
          TRACE( "%p/%lx: WM_STATE deleted from %d\n", data->hwnd, data->whole_window, data->wm_state );
          data->wm_state = WithdrawnState;
          break;
      case PropertyNewValue:
          {
              int old_state = data->wm_state;
              int new_state = get_window_wm_state( event->display, data->whole_window );
              if (new_state != -1 && new_state != data->wm_state)
              {
                  TRACE( "%p/%lx: new WM_STATE %d from %d\n",
                         data->hwnd, data->whole_window, new_state, old_state );
                  data->wm_state = new_state;
                  /* ignore the initial state transition out of withdrawn state */
                  /* metacity does Withdrawn->NormalState->IconicState when mapping an iconic window */
                  if (!old_state) goto done;
              }
          }
          break;
      }
  
      if (!update_window || !data->managed || !data->mapped) goto done;
  
      style = GetWindowLongW( data->hwnd, GWL_STYLE );
  
      if (data->iconic && data->wm_state == NormalState)  /* restore window */
      {
          data->iconic = FALSE;
          read_net_wm_states( event->display, data );
          if ((style & WS_CAPTION) == WS_CAPTION && (data->net_wm_state & (1 << NET_WM_STATE_MAXIMIZED)))
          {
              if ((style & WS_MAXIMIZEBOX) && !(style & WS_DISABLED))
              {
                  TRACE( "restoring to max %p/%lx\n", data->hwnd, data->whole_window );
                  release_win_data( data );
                  SendMessageW( hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
                  return;
              }
              TRACE( "not restoring to max win %p/%lx style %08x\n", data->hwnd, data->whole_window, style );
          }
          else
          {
              if (style & (WS_MINIMIZE | WS_MAXIMIZE))
              {
                  TRACE( "restoring win %p/%lx\n", data->hwnd, data->whole_window );
                  release_win_data( data );
                  SendMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, 0 );
                  return;
              }
              TRACE( "not restoring win %p/%lx style %08x\n", data->hwnd, data->whole_window, style );
          }
      }
      else if (!data->iconic && data->wm_state == IconicState)
      {
          data->iconic = TRUE;
          if ((style & WS_MINIMIZEBOX) && !(style & WS_DISABLED))
          {
              TRACE( "minimizing win %p/%lx\n", data->hwnd, data->whole_window );
              release_win_data( data );
              SendMessageW( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0 );
              return;
          }
          TRACE( "not minimizing win %p/%lx style %08x\n", data->hwnd, data->whole_window, style );
      }
  done:
      release_win_data( data );
  }
  
  
  /***********************************************************************
   *           X11DRV_PropertyNotify
   */
  static BOOL X11DRV_PropertyNotify( HWND hwnd, XEvent *xev )
  {
      XPropertyEvent *event = &xev->xproperty;
  
      if (!hwnd) return FALSE;
      if (event->atom == x11drv_atom(WM_STATE)) handle_wm_state_notify( hwnd, event, TRUE );
      return TRUE;
  }
  
  
  /* event filter to wait for a WM_STATE change notification on a window */
  static Bool is_wm_state_notify( Display *display, XEvent *event, XPointer arg )
  {
      if (event->xany.window != (Window)arg) return 0;
      return (event->type == DestroyNotify ||
              (event->type == PropertyNotify && event->xproperty.atom == x11drv_atom(WM_STATE)));
  }
  
  /***********************************************************************
   *           wait_for_withdrawn_state
   */
  void wait_for_withdrawn_state( HWND hwnd, BOOL set )
  {
      Display *display = thread_display();
      struct x11drv_win_data *data;
      DWORD end = GetTickCount() + 2000;
  
      TRACE( "waiting for window %p to become %swithdrawn\n", hwnd, set ? "" : "not " );
  
      for (;;)
      {
          XEvent event;
          Window window;
          int count = 0;
  
          if (!(data = get_win_data( hwnd ))) break;
          if (!data->managed || data->embedded || data->display != display) break;
          if (!(window = data->whole_window)) break;
          if (!data->mapped == !set)
          {
              TRACE( "window %p/%lx now %smapped\n", hwnd, window, data->mapped ? "" : "un" );
              break;
          }
          if ((data->wm_state == WithdrawnState) != !set)
          {
              TRACE( "window %p/%lx state now %d\n", hwnd, window, data->wm_state );
              break;
          }
          release_win_data( data );
  
          while (XCheckIfEvent( display, &event, is_wm_state_notify, (char *)window ))
          {
              count++;
              if (XFilterEvent( &event, None )) continue;  /* filtered, ignore it */
              if (event.type == DestroyNotify) call_event_handler( display, &event );
              else handle_wm_state_notify( hwnd, &event.xproperty, FALSE );
          }
  
          if (!count)
          {
              struct pollfd pfd;
              int timeout = end - GetTickCount();
  
              pfd.fd = ConnectionNumber(display);
              pfd.events = POLLIN;
              if (timeout <= 0 || poll( &pfd, 1, timeout ) != 1)
              {
                  FIXME( "window %p/%lx wait timed out\n", hwnd, window );
                  return;
              }
          }
      }
      release_win_data( data );
  }
  
  
  /*****************************************************************
   *		SetFocus   (X11DRV.@)
   *
   * Set the X focus.
   */
  void CDECL X11DRV_SetFocus( HWND hwnd )
  {
      struct x11drv_win_data *data;
  
      HWND parent;
  
      for (;;)
      {
          if (!(data = get_win_data( hwnd ))) return;
          if (data->embedded) break;
          parent = GetAncestor( hwnd, GA_PARENT );
          if (!parent || parent == GetDesktopWindow()) break;
          release_win_data( data );
          hwnd = parent;
      }
      if (!data->managed || data->embedder) set_input_focus( data );
      release_win_data( data );
  }
  
  
  static HWND find_drop_window( HWND hQueryWnd, LPPOINT lpPt )
  {
      RECT tempRect;
  
      if (!IsWindowEnabled(hQueryWnd)) return 0;
      
      GetWindowRect(hQueryWnd, &tempRect);
  
      if(!PtInRect(&tempRect, *lpPt)) return 0;
  
      if (!IsIconic( hQueryWnd ))
      {
          POINT pt = *lpPt;
          ScreenToClient( hQueryWnd, &pt );
          GetClientRect( hQueryWnd, &tempRect );
  
          if (PtInRect( &tempRect, pt))
          {
              HWND ret = ChildWindowFromPointEx( hQueryWnd, pt, CWP_SKIPINVISIBLE|CWP_SKIPDISABLED );
              if (ret && ret != hQueryWnd)
              {
                  ret = find_drop_window( ret, lpPt );
                  if (ret) return ret;
              }
          }
      }
  
      if(!(GetWindowLongA( hQueryWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return 0;
      
      ScreenToClient(hQueryWnd, lpPt);
  
      return hQueryWnd;
  }
  
  /**********************************************************************
   *           EVENT_DropFromOffix
   *
   * don't know if it still works (last Changelog is from 96/11/04)
   */
  static void EVENT_DropFromOffiX( HWND hWnd, XClientMessageEvent *event )
  {
      struct x11drv_win_data *data;
      POINT pt;
      unsigned long	data_length;
      unsigned long	aux_long;
      unsigned char*	p_data = NULL;
      Atom atom_aux;
      int			x, y, cx, cy, dummy;
      Window		win, w_aux_root, w_aux_child;
  
      if (!(data = get_win_data( hWnd ))) return;
      ERR("TODO: fs hack\n");
      cx = data->whole_rect.right - data->whole_rect.left;
      cy = data->whole_rect.bottom - data->whole_rect.top;
      win = data->whole_window;
      release_win_data( data );
  
      XQueryPointer( event->display, win, &w_aux_root, &w_aux_child,
                     &x, &y, &dummy, &dummy, (unsigned int*)&aux_long);
      pt = root_to_virtual_screen( x, y );
  
      /* find out drop point and drop window */
      if (pt.x < 0 || pt.y < 0 || pt.x > cx || pt.y > cy)
      {
  	if (!(GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return;
  	pt.x = pt.y = 0;
      }
      else
      {
          if (!find_drop_window( hWnd, &pt )) return;
      }
  
      XGetWindowProperty( event->display, DefaultRootWindow(event->display),
                          x11drv_atom(DndSelection), 0, 65535, FALSE,
                          AnyPropertyType, &atom_aux, &dummy,
                          &data_length, &aux_long, &p_data);
  
      if( !aux_long && p_data)  /* don't bother if > 64K */
      {
          char *p = (char *)p_data;
          char *p_drop;
  
          aux_long = 0;
          while( *p )  /* calculate buffer size */
          {
              INT len = GetShortPathNameA( p, NULL, 0 );
              if (len) aux_long += len + 1;
              p += strlen(p) + 1;
          }
          if( aux_long && aux_long < 65535 )
          {
              HDROP                 hDrop;
              DROPFILES *lpDrop;
  
              aux_long += sizeof(DROPFILES) + 1;
              hDrop = GlobalAlloc( GMEM_SHARE, aux_long );
              lpDrop = GlobalLock( hDrop );
  
              if( lpDrop )
              {
                  lpDrop->pFiles = sizeof(DROPFILES);
                  lpDrop->pt = pt;
                  lpDrop->fNC = FALSE;
                  lpDrop->fWide = FALSE;
                  p_drop = (char *)(lpDrop + 1);
                  p = (char *)p_data;
                  while(*p)
                  {
                      if (GetShortPathNameA( p, p_drop, aux_long - (p_drop - (char *)lpDrop) ))
                          p_drop += strlen( p_drop ) + 1;
                      p += strlen(p) + 1;
                  }
                  *p_drop = '\0';
                  PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
              }
          }
      }
      if( p_data ) XFree(p_data);
  }
  
  /**********************************************************************
   *           EVENT_DropURLs
   *
   * drop items are separated by \n
   * each item is prefixed by its mime type
   *
   * event->data.l[3], event->data.l[4] contains drop x,y position
   */
  static void EVENT_DropURLs( HWND hWnd, XClientMessageEvent *event )
  {
    struct x11drv_win_data *win_data;
    unsigned long	data_length;
    unsigned long	aux_long, drop_len = 0;
    unsigned char	*p_data = NULL; /* property data */
    char		*p_drop = NULL;
    char          *p, *next;
    int		x, y;
    POINT pos;
    DROPFILES *lpDrop;
    HDROP hDrop;
    union {
      Atom	atom_aux;
      int         i;
      Window      w_aux;
      unsigned int u;
    }		u; /* unused */
  
    if (!(GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return;
  
    XGetWindowProperty( event->display, DefaultRootWindow(event->display),
                        x11drv_atom(DndSelection), 0, 65535, FALSE,
                        AnyPropertyType, &u.atom_aux, &u.i,
                        &data_length, &aux_long, &p_data);
    if (aux_long)
      WARN("property too large, truncated!\n");
    TRACE("urls=%s\n", p_data);
  
    if( !aux_long && p_data) {	/* don't bother if > 64K */
      /* calculate length */
      p = (char*) p_data;
      next = strchr(p, '\n');
      while (p) {
        if (next) *next=0;
        if (strncmp(p,"file:",5) == 0 ) {
  	INT len = GetShortPathNameA( p+5, NULL, 0 );
  	if (len) drop_len += len + 1;
        }
        if (next) {
  	*next = '\n';
  	p = next + 1;
  	next = strchr(p, '\n');
        } else {
  	p = NULL;
        }
      }
  
      if( drop_len && drop_len < 65535 ) {
        XQueryPointer( event->display, root_window, &u.w_aux, &u.w_aux,
                       &x, &y, &u.i, &u.i, &u.u);
        pos = root_to_virtual_screen( x, y );
  
        drop_len += sizeof(DROPFILES) + 1;
        hDrop = GlobalAlloc( GMEM_SHARE, drop_len );
        lpDrop = GlobalLock( hDrop );
  
        if( lpDrop && (win_data = get_win_data( hWnd )))
        {
  	  lpDrop->pFiles = sizeof(DROPFILES);
  	  lpDrop->pt = pos;
  	  lpDrop->fNC =
  	    (pos.x < (win_data->client_rect.left - win_data->whole_rect.left)  ||
  	     pos.y < (win_data->client_rect.top - win_data->whole_rect.top)    ||
  	     pos.x > (win_data->client_rect.right - win_data->whole_rect.left) ||
  	     pos.y > (win_data->client_rect.bottom - win_data->whole_rect.top) );
  	  lpDrop->fWide = FALSE;
  	  p_drop = (char*)(lpDrop + 1);
            release_win_data( win_data );
        }
  
        /* create message content */
        if (p_drop) {
  	p = (char*) p_data;
  	next = strchr(p, '\n');
  	while (p) {
  	  if (next) *next=0;
  	  if (strncmp(p,"file:",5) == 0 ) {
  	    INT len = GetShortPathNameA( p+5, p_drop, 65535 );
  	    if (len) {
  	      TRACE("drop file %s as %s\n", p+5, p_drop);
  	      p_drop += len+1;
  	    } else {
  	      WARN("can't convert file %s to dos name\n", p+5);
  	    }
  	  } else {
  	    WARN("unknown mime type %s\n", p);
  	  }
  	  if (next) {
  	    *next = '\n';
  	    p = next + 1;
  	    next = strchr(p, '\n');
  	  } else {
  	    p = NULL;
  	  }
  	  *p_drop = '\0';
  	}
  
          GlobalUnlock(hDrop);
          PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
        }
      }
      if( p_data ) XFree(p_data);
    }
  }
  
  
  /**********************************************************************
   *              handle_xembed_protocol
   */
  static void handle_xembed_protocol( HWND hwnd, XClientMessageEvent *event )
  {
      switch (event->data.l[1])
      {
      case XEMBED_EMBEDDED_NOTIFY:
          {
              struct x11drv_win_data *data = get_win_data( hwnd );
              if (!data) break;
  
              TRACE( "win %p/%lx XEMBED_EMBEDDED_NOTIFY owner %lx\n", hwnd, event->window, event->data.l[3] );
              data->embedder = event->data.l[3];
  
              /* window has been marked as embedded before (e.g. systray) */
              if (data->embedded || !data->embedder /* broken QX11EmbedContainer implementation */)
              {
                  release_win_data( data );
                  break;
              }
  
              make_window_embedded( data );
              release_win_data( data );
              reparent_notify( event->display, hwnd, event->data.l[3], 0, 0 );
          }
          break;
  
      case XEMBED_WINDOW_DEACTIVATE:
          TRACE( "win %p/%lx XEMBED_WINDOW_DEACTIVATE message\n", hwnd, event->window );
          focus_out( event->display, GetAncestor( hwnd, GA_ROOT ) );
          break;
  
      case XEMBED_FOCUS_OUT:
          TRACE( "win %p/%lx XEMBED_FOCUS_OUT message\n", hwnd, event->window );
          focus_out( event->display, GetAncestor( hwnd, GA_ROOT ) );
          break;
  
      case XEMBED_MODALITY_ON:
          TRACE( "win %p/%lx XEMBED_MODALITY_ON message\n", hwnd, event->window );
          EnableWindow( hwnd, FALSE );
          break;
  
      case XEMBED_MODALITY_OFF:
          TRACE( "win %p/%lx XEMBED_MODALITY_OFF message\n", hwnd, event->window );
          EnableWindow( hwnd, TRUE );
          break;
  
      default:
          TRACE( "win %p/%lx XEMBED message %lu(%lu)\n",
                 hwnd, event->window, event->data.l[1], event->data.l[2] );
          break;
      }
  }
  
  
  /**********************************************************************
   *              handle_dnd_protocol
   */
  static void handle_dnd_protocol( HWND hwnd, XClientMessageEvent *event )
  {
      Window root, child;
      int root_x, root_y, child_x, child_y;
      unsigned int u;
  
      /* query window (drag&drop event contains only drag window) */
      XQueryPointer( event->display, root_window, &root, &child,
                     &root_x, &root_y, &child_x, &child_y, &u);
      if (XFindContext( event->display, child, winContext, (char **)&hwnd ) != 0) hwnd = 0;
      if (!hwnd) return;
      if (event->data.l[0] == DndFile || event->data.l[0] == DndFiles)
          EVENT_DropFromOffiX(hwnd, event);
      else if (event->data.l[0] == DndURL)
          EVENT_DropURLs(hwnd, event);
  }
  
  
  struct client_message_handler
  {
      int    atom;                                  /* protocol atom */
      void (*handler)(HWND, XClientMessageEvent *); /* corresponding handler function */
  };
  
  static const struct client_message_handler client_messages[] =
  {
      { XATOM_MANAGER,      handle_manager_message },
      { XATOM_WM_PROTOCOLS, handle_wm_protocols },
      { XATOM__XEMBED,      handle_xembed_protocol },
      { XATOM_DndProtocol,  handle_dnd_protocol },
      { XATOM_XdndEnter,    X11DRV_XDND_EnterEvent },
      { XATOM_XdndPosition, X11DRV_XDND_PositionEvent },
      { XATOM_XdndDrop,     X11DRV_XDND_DropEvent },
      { XATOM_XdndLeave,    X11DRV_XDND_LeaveEvent }
  };
  
  
  /**********************************************************************
   *           X11DRV_ClientMessage
   */
  static BOOL X11DRV_ClientMessage( HWND hwnd, XEvent *xev )
  {
      XClientMessageEvent *event = &xev->xclient;
      unsigned int i;
  
      if (!hwnd) return FALSE;
  
      if (event->format != 32)
      {
          WARN( "Don't know how to handle format %d\n", event->format );
          return FALSE;
      }
  
      for (i = 0; i < sizeof(client_messages)/sizeof(client_messages[0]); i++)
      {
          if (event->message_type == X11DRV_Atoms[client_messages[i].atom - FIRST_XATOM])
          {
              client_messages[i].handler( hwnd, event );
              return TRUE;
          }
      }
      TRACE( "no handler found for %ld\n", event->message_type );
      return FALSE;
  }
  