/* GDK - The GIMP Drawing Kit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 * Copyright (C) 1998-2002 Tor Lillqvist

 * Copyright (C) 2001,2009 Hans Breuer

 * Copyright (C) 2007-2009 Cody Russell

 *

 * 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 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

/* Cannot use TrackMouseEvent, as the stupid WM_MOUSELEAVE message

 * doesn't tell us where the mouse has gone. Thus we cannot use it to

 * generate a correct GdkNotifyType. Pity, as using TrackMouseEvent

 * otherwise would make it possible to reliably generate

 * GDK_LEAVE_NOTIFY events, which would help get rid of those pesky

 * tooltips sometimes popping up in the wrong place.

 *

 * Update: a combination of TrackMouseEvent, GetCursorPos and 

 * GetWindowPos can and is actually used to get rid of those

 * pesky tooltips. It should be possible to use this for the

 * whole ENTER/LEAVE NOTIFY handling but some platforms may

 * not have TrackMouseEvent at all (?) --hb

 */

#include "config.h"

#include <glib/gprintf.h>

#include "gdk.h"

#include "gdkprivate-win32.h"

#include "gdkinput-win32.h"

#include "gdkkeysyms.h"

#include <windowsx.h>

#ifdef G_WITH_CYGWIN

#include <fcntl.h>

#include <errno.h>

#endif

#include <objbase.h>

#include <imm.h>

#ifndef XBUTTON1

#define XBUTTON1 1

#define XBUTTON2 2

#endif

#ifndef VK_XBUTTON1

#define VK_XBUTTON1 5

#define VK_XBUTTON2 6

#endif

#ifndef MK_XBUTTON1

#define MK_XBUTTON1 32

#define MK_XBUTTON2 64

#endif

/* Undefined flags: */

#define SWP_NOCLIENTSIZE 0x0800

#define SWP_NOCLIENTMOVE 0x1000

#define SWP_STATECHANGED 0x8000

/* 

 * Private function declarations

 */

#define SYNAPSIS_ICON_WINDOW_CLASS "SynTrackCursorWindowClass"

static gboolean gdk_event_translate (MSG        *msg,

				     gint       *ret_valp);

static void     handle_wm_paint     (MSG        *msg,

				     GdkWindow  *window,

				     gboolean    return_exposes,

				     GdkEvent  **event);

static gboolean gdk_event_prepare  (GSource     *source,

				    gint        *timeout);

static gboolean gdk_event_check    (GSource     *source);

static gboolean gdk_event_dispatch (GSource     *source,

				    GSourceFunc  callback,

				    gpointer     user_data);

/* Private variable declarations

 */

static GList *client_filters;	/* Filters for client messages */

static HCURSOR p_grab_cursor;

static GSourceFuncs event_funcs = {

  gdk_event_prepare,

  gdk_event_check,

  gdk_event_dispatch,

  NULL

};

GPollFD event_poll_fd;

static GdkWindow *mouse_window = NULL;

static GdkWindow *mouse_window_ignored_leave = NULL;

static gint current_x, current_y;

static gint current_root_x, current_root_y;

static UINT client_message;

static UINT got_gdk_events_message;

static HWND modal_win32_dialog = NULL;

#if 0

static HKL latin_locale = NULL;

#endif

static gboolean in_ime_composition = FALSE;

static UINT     modal_timer;

static UINT     sync_timer = 0;

static int debug_indent = 0;

static void

assign_object (gpointer lhsp,

	       gpointer rhs)

{

  if (*(gpointer *)lhsp != rhs)

    {

      if (*(gpointer *)lhsp != NULL)

	g_object_unref (*(gpointer *)lhsp);

      *(gpointer *)lhsp = rhs;

      if (rhs != NULL)

	g_object_ref (rhs);

    }

}

static void

track_mouse_event (DWORD dwFlags,

		   HWND  hwnd)

{

  TRACKMOUSEEVENT tme;

  tme.cbSize = sizeof(TRACKMOUSEEVENT);

  tme.dwFlags = dwFlags;

  tme.hwndTrack = hwnd;

  tme.dwHoverTime = HOVER_DEFAULT; /* not used */

  if (!TrackMouseEvent (&tme))

    WIN32_API_FAILED ("TrackMouseEvent");

  else if (dwFlags == TME_LEAVE)

    GDK_NOTE (EVENTS, g_print(" (TrackMouseEvent %p)", hwnd));

  else if (dwFlags == TME_CANCEL)

    GDK_NOTE (EVENTS, g_print(" (cancel TrackMouseEvent %p)", hwnd));

}

gulong

_gdk_win32_get_next_tick (gulong suggested_tick)

{

  static gulong cur_tick = 0;

  if (suggested_tick == 0)

    suggested_tick = GetTickCount ();

  if (suggested_tick <= cur_tick)

    return cur_tick;

  else

    return cur_tick = suggested_tick;

}

static void

generate_focus_event (GdkWindow *window,

		      gboolean   in)

{

  GdkEvent *event;

  event = gdk_event_new (GDK_FOCUS_CHANGE);

  event->focus_change.window = window;

  event->focus_change.in = in;

  _gdk_win32_append_event (event);

}

static void

generate_grab_broken_event (GdkWindow *window,

			    gboolean   keyboard,

			    GdkWindow *grab_window)

{

  GdkEvent *event = gdk_event_new (GDK_GRAB_BROKEN);

  event->grab_broken.window = window;

  event->grab_broken.send_event = 0;

  event->grab_broken.keyboard = keyboard;

  event->grab_broken.implicit = FALSE;

  event->grab_broken.grab_window = grab_window;

  _gdk_win32_append_event (event);

}

static LRESULT 

inner_window_procedure (HWND   hwnd,

			UINT   message,

			WPARAM wparam,

			LPARAM lparam)

{

  MSG msg;

  DWORD pos;

  gint ret_val = 0;

  msg.hwnd = hwnd;

  msg.message = message;

  msg.wParam = wparam;

  msg.lParam = lparam;

  msg.time = _gdk_win32_get_next_tick (0);

  pos = GetMessagePos ();

  msg.pt.x = GET_X_LPARAM (pos);

  msg.pt.y = GET_Y_LPARAM (pos);

  if (gdk_event_translate (&msg, &ret_val))

    {

      /* If gdk_event_translate() returns TRUE, we return ret_val from

       * the window procedure.

       */

      if (modal_win32_dialog)

	PostMessageW (modal_win32_dialog, got_gdk_events_message,

		      (WPARAM) 1, 0);

      return ret_val;

    }

  else

    {

      /* Otherwise call DefWindowProcW(). */

      GDK_NOTE (EVENTS, g_print (" DefWindowProcW"));

      return DefWindowProcW (hwnd, message, wparam, lparam);

    }

}

LRESULT CALLBACK

_gdk_win32_window_procedure (HWND   hwnd,

                             UINT   message,

                             WPARAM wparam,

                             LPARAM lparam)

{

  LRESULT retval;

  GDK_NOTE (EVENTS, g_print ("%s%*s%s %p",

			     (debug_indent > 0 ? "\n" : ""),

			     debug_indent, "", 

			     _gdk_win32_message_to_string (message), hwnd));

  debug_indent += 2;

  retval = inner_window_procedure (hwnd, message, wparam, lparam);

  debug_indent -= 2;

  GDK_NOTE (EVENTS, g_print (" => %I64d%s", (gint64) retval, (debug_indent == 0 ? "\n" : "")));

  return retval;

}

void 

_gdk_events_init (void)

{

  GSource *source;

#if 0

  int i, j, n;

  /* List of languages that use a latin keyboard. Somewhat sorted in

   * "order of least surprise", in case we have to load one of them if

   * the user only has arabic loaded, for instance.

   */

  static int latin_languages[] = {

    LANG_ENGLISH,

    LANG_SPANISH,

    LANG_PORTUGUESE,

    LANG_FRENCH,

    LANG_GERMAN,

    /* Rest in numeric order */

    LANG_CZECH,

    LANG_DANISH,

    LANG_FINNISH,

    LANG_HUNGARIAN,

    LANG_ICELANDIC,

    LANG_ITALIAN,

    LANG_DUTCH,

    LANG_NORWEGIAN,

    LANG_POLISH,

    LANG_ROMANIAN,

    LANG_SLOVAK,

    LANG_ALBANIAN,

    LANG_SWEDISH,

    LANG_TURKISH,

    LANG_INDONESIAN,

    LANG_SLOVENIAN,

    LANG_ESTONIAN,

    LANG_LATVIAN,

    LANG_LITHUANIAN,

    LANG_VIETNAMESE,

    LANG_AFRIKAANS,

    LANG_FAEROESE

#ifdef LANG_SWAHILI

   ,LANG_SWAHILI

#endif

  };

#endif

  client_message = RegisterWindowMessage ("GDK_WIN32_CLIENT_MESSAGE");

  got_gdk_events_message = RegisterWindowMessage ("GDK_WIN32_GOT_EVENTS");

#if 0

  /* Check if we have some input locale identifier loaded that uses a

   * latin keyboard, to be able to get the virtual-key code for the

   * latin characters corresponding to ASCII control characters.

   */

  if ((n = GetKeyboardLayoutList (0, NULL)) == 0)

    WIN32_API_FAILED ("GetKeyboardLayoutList");

  else

    {

      HKL *hkl_list = g_new (HKL, n);

      if (GetKeyboardLayoutList (n, hkl_list) == 0)

	WIN32_API_FAILED ("GetKeyboardLayoutList");

      else

	{

	  for (i = 0; latin_locale == NULL && i < n; i++)

	    for (j = 0; j < G_N_ELEMENTS (latin_languages); j++)

	      if (PRIMARYLANGID (LOWORD (hkl_list[i])) == latin_languages[j])

		{

		  latin_locale = hkl_list [i];

		  break;

		}

	}

      g_free (hkl_list);

    }

  if (latin_locale == NULL)

    {

      /* Try to load a keyboard layout with latin characters then.

       */

      i = 0;

      while (latin_locale == NULL && i < G_N_ELEMENTS (latin_languages))

	{

	  char id[9];

	  g_sprintf (id, "%08x", MAKELANGID (latin_languages[i++], SUBLANG_DEFAULT));

	  latin_locale = LoadKeyboardLayout (id, KLF_NOTELLSHELL|KLF_SUBSTITUTE_OK);

	}

    }

  GDK_NOTE (EVENTS, g_print ("latin_locale = %08x\n", (guint) latin_locale));

#endif

  source = g_source_new (&event_funcs, sizeof (GSource));

  g_source_set_name (source, "GDK Win32 event source"); 

  g_source_set_priority (source, GDK_PRIORITY_EVENTS);

#ifdef G_WITH_CYGWIN

  event_poll_fd.fd = open ("/dev/windows", O_RDONLY);

  if (event_poll_fd.fd == -1)

    g_error ("can't open \"/dev/windows\": %s", g_strerror (errno));

#else

  event_poll_fd.fd = G_WIN32_MSG_HANDLE;

#endif

  event_poll_fd.events = G_IO_IN;

  g_source_add_poll (source, &event_poll_fd);

  g_source_set_can_recurse (source, TRUE);

  g_source_attach (source, NULL);

}

gboolean

gdk_events_pending (void)

{

  return (_gdk_event_queue_find_first (_gdk_display) ||

	  (modal_win32_dialog == NULL &&

	   GetQueueStatus (QS_ALLINPUT) != 0));

}

GdkEvent*

gdk_event_get_graphics_expose (GdkWindow *window)

{

  MSG msg;

  GdkEvent *event = NULL;

  g_return_val_if_fail (window != NULL, NULL);

  GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose\n"));

  if (PeekMessageW (&msg, GDK_WINDOW_HWND (window), WM_PAINT, WM_PAINT, PM_REMOVE))

    {

      handle_wm_paint (&msg, window, TRUE, &event);

      if (event != NULL)

	{

	  GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose: got it!\n"));

	  return event;

	}

    }

  GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose: nope\n"));

  return NULL;	

}

#if 0 /* Unused, but might be useful to re-introduce in some debugging output? */

static char *

event_mask_string (GdkEventMask mask)

{

  static char bfr[500];

  char *p = bfr;

  *p = '\0';

#define BIT(x) \

  if (mask & GDK_##x##_MASK) \

    p += g_sprintf (p, "%s" #x, (p > bfr ? " " : ""))

  BIT (EXPOSURE);

  BIT (POINTER_MOTION);

  BIT (POINTER_MOTION_HINT);

  BIT (BUTTON_MOTION);

  BIT (BUTTON1_MOTION);

  BIT (BUTTON2_MOTION);

  BIT (BUTTON3_MOTION);

  BIT (BUTTON_PRESS);

  BIT (BUTTON_RELEASE);

  BIT (KEY_PRESS);

  BIT (KEY_RELEASE);

  BIT (ENTER_NOTIFY);

  BIT (LEAVE_NOTIFY);

  BIT (FOCUS_CHANGE);

  BIT (STRUCTURE);

  BIT (PROPERTY_CHANGE);

  BIT (VISIBILITY_NOTIFY);

  BIT (PROXIMITY_IN);

  BIT (PROXIMITY_OUT);

  BIT (SUBSTRUCTURE);

  BIT (SCROLL);

#undef BIT

  return bfr;

}

#endif

GdkGrabStatus

_gdk_windowing_pointer_grab (GdkWindow    *window,

			     GdkWindow    *native_window,

			     gboolean	owner_events,

			     GdkEventMask	event_mask,

			     GdkWindow    *confine_to,

			     GdkCursor    *cursor,

			     guint32	time)

{

  HCURSOR hcursor;

  GdkCursorPrivate *cursor_private;

  gint return_val;

  g_return_val_if_fail (window != NULL, 0);

  g_return_val_if_fail (GDK_IS_WINDOW (window), 0);

  g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);

  cursor_private = (GdkCursorPrivate*) cursor;

  if (!cursor)

    hcursor = NULL;

  else if ((hcursor = CopyCursor (cursor_private->hcursor)) == NULL)

    WIN32_API_FAILED ("CopyCursor");

  return_val = _gdk_input_grab_pointer (native_window,

					owner_events,

					event_mask,

					confine_to,

					time);

  if (return_val == GDK_GRAB_SUCCESS)

    {

      GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) native_window)->impl);

      SetCapture (GDK_WINDOW_HWND (native_window));

      /* TODO_CSW: grab brokens, confine window, input_grab */

      if (p_grab_cursor != NULL)

	{

	  if (GetCursor () == p_grab_cursor)

	    SetCursor (NULL);

	  DestroyCursor (p_grab_cursor);

	}

      p_grab_cursor = hcursor;

      if (p_grab_cursor != NULL)

	SetCursor (p_grab_cursor);

      else if (impl->hcursor != NULL)

	SetCursor (impl->hcursor);

      else

	SetCursor (LoadCursor (NULL, IDC_ARROW));

    }

  return return_val;

}

void

gdk_display_pointer_ungrab (GdkDisplay *display,

                            guint32     time)

{

  GdkPointerGrabInfo *info;

  info = _gdk_display_get_last_pointer_grab (display);

  if (info)

    {

      info->serial_end = 0;

      ReleaseCapture ();

    }

  _gdk_input_ungrab_pointer (time);

  /* TODO_CSW: cursor, confines, etc */

  _gdk_display_pointer_grab_update (display, 0);

}

static GdkWindow *

find_window_for_mouse_event (GdkWindow* reported_window,

			     MSG*       msg)

{

  POINT pt;

  GdkWindow *event_window;

  HWND hwnd;

  RECT rect;

  GdkPointerGrabInfo *grab;

  grab = _gdk_display_get_last_pointer_grab (_gdk_display);

  if (grab == NULL)

    return reported_window;

  pt = msg->pt;

  if (!grab->owner_events)

    event_window = grab->native_window;

  else

    {

      event_window = NULL;

      hwnd = WindowFromPoint (pt);

      if (hwnd != NULL)

	{

	  POINT client_pt = pt;

	  ScreenToClient (hwnd, &client_pt);

	  GetClientRect (hwnd, &rect);

	  if (PtInRect (&rect, client_pt))

	    event_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);

	}

      if (event_window == NULL)

	event_window = grab->native_window;

    }

  /* need to also adjust the coordinates to the new window */

  ScreenToClient (GDK_WINDOW_HWND (event_window), &pt;;

  /* ATTENTION: need to update client coords */

  msg->lParam = MAKELPARAM (pt.x, pt.y);

  return event_window;

}

GdkGrabStatus

gdk_keyboard_grab (GdkWindow *window,

		   gboolean   owner_events,

		   guint32    time)

{

  GdkDisplay *display;

  GdkWindow  *toplevel;

  g_return_val_if_fail (window != NULL, 0);

  g_return_val_if_fail (GDK_IS_WINDOW (window), 0);

  GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %p%s\n",

			     GDK_WINDOW_HWND (window), owner_events ? " OWNER_EVENTS" : ""));

  display = gdk_drawable_get_display (window);

  toplevel = gdk_window_get_toplevel (window);

  _gdk_display_set_has_keyboard_grab (display,

				      window,

				      toplevel,

				      owner_events,

				      0,

				      time);

  return GDK_GRAB_SUCCESS;

}

void

gdk_display_keyboard_ungrab (GdkDisplay *display,

                             guint32 time)

{

  GDK_NOTE (EVENTS, g_print ("gdk_display_keyboard_ungrab\n"));

  _gdk_display_unset_has_keyboard_grab (display, FALSE);

}

void 

gdk_display_add_client_message_filter (GdkDisplay   *display,

				       GdkAtom       message_type,

				       GdkFilterFunc func,

				       gpointer      data)

{

  /* XXX */

  gdk_add_client_message_filter (message_type, func, data);

}

void

gdk_add_client_message_filter (GdkAtom       message_type,

			       GdkFilterFunc func,

			       gpointer      data)

{

  GdkClientFilter *filter = g_new (GdkClientFilter, 1);

  filter->type = message_type;

  filter->function = func;

  filter->data = data;

  client_filters = g_list_append (client_filters, filter);

}

static void

build_key_event_state (GdkEvent *event,

		       BYTE     *key_state)

{

  GdkWin32Keymap *keymap;

  event->key.state = 0;

  if (key_state[VK_SHIFT] & 0x80)

    event->key.state |= GDK_SHIFT_MASK;

  if (key_state[VK_CAPITAL] & 0x01)

    event->key.state |= GDK_LOCK_MASK;

  if (key_state[VK_LBUTTON] & 0x80)

    event->key.state |= GDK_BUTTON1_MASK;

  if (key_state[VK_MBUTTON] & 0x80)

    event->key.state |= GDK_BUTTON2_MASK;

  if (key_state[VK_RBUTTON] & 0x80)

    event->key.state |= GDK_BUTTON3_MASK;

  if (key_state[VK_XBUTTON1] & 0x80)

    event->key.state |= GDK_BUTTON4_MASK;

  if (key_state[VK_XBUTTON2] & 0x80)

    event->key.state |= GDK_BUTTON5_MASK;

  keymap = GDK_WIN32_KEYMAP (gdk_keymap_get_default ());

  event->key.group = _gdk_win32_keymap_get_active_group (keymap);

  if (_gdk_win32_keymap_has_altgr (keymap) &&

      (key_state[VK_LCONTROL] & 0x80) &&

      (key_state[VK_RMENU] & 0x80))

    {

      event->key.state |= GDK_MOD2_MASK;

      if (key_state[VK_RCONTROL] & 0x80)

	event->key.state |= GDK_CONTROL_MASK;

      if (key_state[VK_LMENU] & 0x80)

	event->key.state |= GDK_MOD1_MASK;

    }

  else

    {

      if (key_state[VK_CONTROL] & 0x80)

	event->key.state |= GDK_CONTROL_MASK;

      if (key_state[VK_MENU] & 0x80)

	event->key.state |= GDK_MOD1_MASK;

    }

}

static gint

build_pointer_event_state (MSG *msg)

{

  gint state;

  state = 0;

  if (msg->wParam & MK_CONTROL)

    state |= GDK_CONTROL_MASK;

  if ((msg->message != WM_LBUTTONDOWN &&

       (msg->wParam & MK_LBUTTON)) ||

      msg->message == WM_LBUTTONUP)

    state |= GDK_BUTTON1_MASK;

  if ((msg->message != WM_MBUTTONDOWN &&

       (msg->wParam & MK_MBUTTON)) ||

      msg->message == WM_MBUTTONUP)

    state |= GDK_BUTTON2_MASK;

  if ((msg->message != WM_RBUTTONDOWN &&

       (msg->wParam & MK_RBUTTON)) ||

      msg->message == WM_RBUTTONUP)

    state |= GDK_BUTTON3_MASK;

  if (((msg->message != WM_XBUTTONDOWN || HIWORD (msg->wParam) != XBUTTON1) &&

       (msg->wParam & MK_XBUTTON1)) ||

      (msg->message == WM_XBUTTONUP && HIWORD (msg->wParam) == XBUTTON1))

    state |= GDK_BUTTON4_MASK;

  if (((msg->message != WM_XBUTTONDOWN || HIWORD (msg->wParam) != XBUTTON2) &&

       (msg->wParam & MK_XBUTTON2)) ||

      (msg->message == WM_XBUTTONUP && HIWORD (msg->wParam) == XBUTTON2))

    state |= GDK_BUTTON5_MASK;

  if (msg->wParam & MK_SHIFT)

    state |= GDK_SHIFT_MASK;

  if (GetKeyState (VK_MENU) < 0)

    state |= GDK_MOD1_MASK;

  if (GetKeyState (VK_CAPITAL) & 0x1)

    state |= GDK_LOCK_MASK;

  return state;

}

static void

build_wm_ime_composition_event (GdkEvent *event,

				MSG      *msg,

				wchar_t   wc,

				BYTE     *key_state)

{

  event->key.time = _gdk_win32_get_next_tick (msg->time);

  build_key_event_state (event, key_state);

  event->key.hardware_keycode = 0; /* FIXME: What should it be? */

  event->key.string = NULL;

  event->key.length = 0;

  event->key.keyval = gdk_unicode_to_keyval (wc);

}

#ifdef G_ENABLE_DEBUG

static void

print_event_state (guint state)

{

#define CASE(bit) if (state & GDK_ ## bit ## _MASK) g_print (#bit " ");

  CASE (SHIFT);

  CASE (LOCK);

  CASE (CONTROL);

  CASE (MOD1);

  CASE (MOD2);

  CASE (MOD3);

  CASE (MOD4);

  CASE (MOD5);

  CASE (BUTTON1);

  CASE (BUTTON2);

  CASE (BUTTON3);

  CASE (BUTTON4);

  CASE (BUTTON5);

#undef CASE

}

void

_gdk_win32_print_event (const GdkEvent *event)

{

  gchar *escaped, *kvname;

  gchar *selection_name, *target_name, *property_name;

  g_print ("%s%*s===> ", (debug_indent > 0 ? "\n" : ""), debug_indent, "");

  switch (event->any.type)

    {

#define CASE(x) case x: g_print (#x); break;

    CASE (GDK_NOTHING);

    CASE (GDK_DELETE);

    CASE (GDK_DESTROY);

    CASE (GDK_EXPOSE);

    CASE (GDK_MOTION_NOTIFY);

    CASE (GDK_BUTTON_PRESS);

    CASE (GDK_2BUTTON_PRESS);

    CASE (GDK_3BUTTON_PRESS);

    CASE (GDK_BUTTON_RELEASE);

    CASE (GDK_KEY_PRESS);

    CASE (GDK_KEY_RELEASE);

    CASE (GDK_ENTER_NOTIFY);

    CASE (GDK_LEAVE_NOTIFY);

    CASE (GDK_FOCUS_CHANGE);

    CASE (GDK_CONFIGURE);

    CASE (GDK_MAP);

    CASE (GDK_UNMAP);

    CASE (GDK_PROPERTY_NOTIFY);

    CASE (GDK_SELECTION_CLEAR);

    CASE (GDK_SELECTION_REQUEST);

    CASE (GDK_SELECTION_NOTIFY);

    CASE (GDK_PROXIMITY_IN);

    CASE (GDK_PROXIMITY_OUT);

    CASE (GDK_DRAG_ENTER);

    CASE (GDK_DRAG_LEAVE);

    CASE (GDK_DRAG_MOTION);

    CASE (GDK_DRAG_STATUS);

    CASE (GDK_DROP_START);

    CASE (GDK_DROP_FINISHED);

    CASE (GDK_CLIENT_EVENT);

    CASE (GDK_VISIBILITY_NOTIFY);

    CASE (GDK_NO_EXPOSE);

    CASE (GDK_SCROLL);

    CASE (GDK_WINDOW_STATE);

    CASE (GDK_SETTING);

    CASE (GDK_OWNER_CHANGE);

    CASE (GDK_GRAB_BROKEN);

#undef CASE

    default: g_assert_not_reached ();

    }

  g_print (" %p ", event->any.window ? GDK_WINDOW_HWND (event->any.window) : NULL);

  switch (event->any.type)

    {

    case GDK_EXPOSE:

      g_print ("%s %d",

	       _gdk_win32_gdkrectangle_to_string (&event->expose.area),

	       event->expose.count);

      break;

    case GDK_MOTION_NOTIFY:

      g_print ("(%.4g,%.4g) (%.4g,%.4g) %s",

	       event->motion.x, event->motion.y,

	       event->motion.x_root, event->motion.y_root,

	       event->motion.is_hint ? "HINT " : "");

      print_event_state (event->motion.state);

      break;

    case GDK_BUTTON_PRESS:

    case GDK_2BUTTON_PRESS:

    case GDK_3BUTTON_PRESS:

    case GDK_BUTTON_RELEASE:

      g_print ("%d (%.4g,%.4g) (%.4g,%.4g) ",

	       event->button.button,

	       event->button.x, event->button.y,

	       event->button.x_root, event->button.y_root);

      print_event_state (event->button.state);

      break;

    case GDK_KEY_PRESS: 

    case GDK_KEY_RELEASE:

      if (event->key.length == 0)

	escaped = g_strdup ("");

      else

	escaped = g_strescape (event->key.string, NULL);

      kvname = gdk_keyval_name (event->key.keyval);

      g_print ("%#.02x group:%d %s %d:\"%s\" ",

	       event->key.hardware_keycode, event->key.group,

	       (kvname ? kvname : "??"),

	       event->key.length,

	       escaped);

      g_free (escaped);

      print_event_state (event->key.state);

      break;

    case GDK_ENTER_NOTIFY:

    case GDK_LEAVE_NOTIFY:

      g_print ("%p (%.4g,%.4g) (%.4g,%.4g) %s %s%s",

	       event->crossing.subwindow == NULL ? NULL : GDK_WINDOW_HWND (event->crossing.subwindow),

	       event->crossing.x, event->crossing.y,

	       event->crossing.x_root, event->crossing.y_root,

	       (event->crossing.mode == GDK_CROSSING_NORMAL ? "NORMAL" :

		(event->crossing.mode == GDK_CROSSING_GRAB ? "GRAB" :

		 (event->crossing.mode == GDK_CROSSING_UNGRAB ? "UNGRAB" :

		  "???"))),

	       (event->crossing.detail == GDK_NOTIFY_ANCESTOR ? "ANCESTOR" :

		(event->crossing.detail == GDK_NOTIFY_VIRTUAL ? "VIRTUAL" :

		 (event->crossing.detail == GDK_NOTIFY_INFERIOR ? "INFERIOR" :

		  (event->crossing.detail == GDK_NOTIFY_NONLINEAR ? "NONLINEAR" :

		   (event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL ? "NONLINEAR_VIRTUAL" :

		    (event->crossing.detail == GDK_NOTIFY_UNKNOWN ? "UNKNOWN" :

		     "???")))))),

	       event->crossing.focus ? " FOCUS" : "");

      print_event_state (event->crossing.state);

      break;

    case GDK_FOCUS_CHANGE:

      g_print ("%s", (event->focus_change.in ? "IN" : "OUT"));

      break;

    case GDK_CONFIGURE: