Index: gdk/win32/bdfcursor.c
===================================================================
--- gdk/win32/bdfcursor.c	(revision 18613)
+++ gdk/win32/bdfcursor.c	(working copy)
@@ -17,7 +17,6 @@
  * Boston, MA 02111-1307, USA.
  */
 
-#include <config.h>
 #include <string.h>
 #include <stdio.h>
 #include <errno.h>
Index: gdk/win32/gdkevents-win32.c
===================================================================
--- gdk/win32/gdkevents-win32.c	(revision 18613)
+++ gdk/win32/gdkevents-win32.c	(working copy)
@@ -1335,6 +1335,37 @@
   return result;
 }
 
+static void
+show_window_recurse (GdkWindow *window, gboolean hide_window)
+{
+  GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+  GSList *children = impl->transient_children;
+  GdkWindow *child = NULL;
+
+  if (!impl->changing_state)
+    {
+      impl->changing_state = TRUE;
+
+      if (children != NULL)
+        {
+          while (children != NULL)
+	    {
+	      child = children->data;
+	      show_window_recurse (child, hide_window);
+
+              children = g_slist_next (children);
+	    }
+        }
+
+      if (!hide_window)
+        ShowWindow (GDK_WINDOW_HWND (window), SW_RESTORE);
+      else
+        ShowWindow (GDK_WINDOW_HWND (window), SW_MINIMIZE);
+
+      impl->changing_state = FALSE;
+    }
+}
+
 static gboolean
 gdk_window_is_ancestor (GdkWindow *ancestor,
 			GdkWindow *window)
@@ -2896,15 +2927,17 @@
 	    {
 	      SetForegroundWindow (GDK_WINDOW_HWND (impl->transient_owner));
 	    }
-	}
 
-      if (event->any.type == GDK_UNMAP &&
-	  p_grab_window == window)
-	gdk_pointer_ungrab (msg->time);
+	  if (p_grab_window == window)
+	    {
+	      gdk_pointer_ungrab (msg->time);
+	    }
 
-      if (event->any.type == GDK_UNMAP &&
-	  k_grab_window == window)
-	gdk_keyboard_ungrab (msg->time);
+	  if (k_grab_window == window)
+	    {
+	      gdk_keyboard_ungrab (msg->time);
+	    }
+	}
 
       return_val = TRUE;
       break;
@@ -3441,6 +3474,47 @@
       else
 	gdk_event_free (event);
       break;
+#else
+    case WM_ACTIVATE:
+	;
+
+        /*
+         * On Windows, transient windows will not have their own taskbar entries.
+         * Because of this, we must hide and restore groups of transients in both
+         * directions.  That is, all transient children must be hidden or restored
+         * with this window, but if this window's transient owner also has a
+         * transient owner then this window's transient owner must be hidden/restored
+         * with this one.  And etc, up the chain until we hit an ancestor that has no
+         * transient owner.
+         *
+         * It would be a good idea if applications don't chain transient windows
+         * together.  There's a limit to how much evil GTK can try to shield you
+         * from.
+         */
+        GdkWindow *tmp_window = NULL;
+        GdkWindowImplWin32 *tmp_impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+
+        while (tmp_impl->transient_owner != NULL)
+          {
+            tmp_window = tmp_impl->transient_owner;
+            tmp_impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (tmp_window)->impl);
+          }
+
+        if (tmp_window == NULL)
+          tmp_window = window;
+
+        if (LOWORD (msg->wParam) == WA_INACTIVE && HIWORD (msg->wParam))
+          {
+            g_print ("Minimized!  %s\n", tmp_impl->changing_state ? "TRUE" : "FALSE");
+            if (!tmp_impl->changing_state)
+              show_window_recurse (tmp_window, TRUE);
+          }
+        else if (LOWORD (msg->wParam) == WA_ACTIVE && HIWORD (msg->wParam))
+          {
+            g_print ("Restored!  %s\n", tmp_impl->changing_state ? "TRUE" : "FALSE");
+	    if (!tmp_impl->changing_state)
+              show_window_recurse (tmp_window, FALSE);
+          }
 #endif
     }
 
Index: gdk/win32/gdkwindow-win32.c
===================================================================
--- gdk/win32/gdkwindow-win32.c	(revision 18613)
+++ gdk/win32/gdkwindow-win32.c	(working copy)
@@ -157,6 +157,9 @@
   impl->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
   impl->extension_events_selected = FALSE;
   impl->transient_owner = NULL;
+  impl->transient_children = NULL;
+  impl->num_transients = 0;
+  impl->changing_state = FALSE;
 }
 
 static void
@@ -871,6 +874,7 @@
 {
   GdkWindowObject *private = (GdkWindowObject *)window;
   GdkWindowImplWin32 *window_impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
+  GSList *tmp;
 
   g_return_if_fail (GDK_IS_WINDOW (window));
   
@@ -880,6 +884,19 @@
   if (private->extension_events != 0)
     _gdk_input_window_destroy (window);
 
+  /* Remove all our transient children */
+  tmp = window_impl->transient_children;
+  while (tmp != NULL)
+    {
+      GdkWindow *child = tmp->data;
+      GdkWindowImplWin32 *child_impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (child)->impl);
+
+      child_impl->transient_owner = NULL;
+      tmp = g_slist_next (tmp);
+    }
+  g_slist_free (window_impl->transient_children);
+  window_impl->transient_children = NULL;
+
   /* Remove ourself from our transient owner */
   if (window_impl->transient_owner != NULL)
     {
@@ -1977,6 +1994,8 @@
 {
   HWND window_id, parent_id;
   GdkWindowImplWin32 *window_impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+  GdkWindowImplWin32 *parent_impl = NULL;
+  GSList *item;
 
   g_return_if_fail (GDK_IS_WINDOW (window));
 
@@ -1999,8 +2018,32 @@
       return;
     }
 
-  window_impl->transient_owner = parent;
+  if (parent == NULL)
+    {
+      GdkWindowImplWin32 *trans_impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window_impl->transient_owner)->impl);
+      if (trans_impl->transient_children != NULL)
+        {
+          item = g_slist_find (trans_impl->transient_children, window);
+          item->data = NULL;
+          trans_impl->transient_children = g_slist_delete_link (trans_impl->transient_children, item);
+          trans_impl->num_transients--;
+          if (!trans_impl->num_transients)
+            {
+              trans_impl->transient_children = NULL;
+            }
+        }
 
+      window_impl->transient_owner = NULL;
+    }
+  else
+    {
+      parent_impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (parent)->impl);
+
+      parent_impl->transient_children = g_slist_append (parent_impl->transient_children, window);
+      parent_impl->num_transients++;
+      window_impl->transient_owner = parent;
+    }
+
   /* This changes the *owner* of the window, despite the misleading
    * name. (Owner and parent are unrelated concepts.) At least that's
    * what people who seem to know what they talk about say on
@@ -2964,7 +3007,7 @@
 	   gint  *nchildren)
 {
   guint i, n;
-  HWND child;
+  HWND child = NULL;
 
   n = 0;
   do {
@@ -3440,7 +3483,7 @@
   GdkWindowObject *private;
 
   g_return_if_fail (GDK_IS_WINDOW (window));
-  
+
   if (GDK_WINDOW_DESTROYED (window))
     return;
 
@@ -3448,7 +3491,7 @@
 
   private->modal_hint = modal;
 
-#if 0
+#if 1
   /* Not sure about this one.. -- Cody */
   if (GDK_WINDOW_IS_MAPPED (window))
     API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), 
@@ -3467,6 +3510,8 @@
 
   g_return_if_fail (GDK_IS_WINDOW (window));
 
+  return;
+
   GDK_NOTE (MISC, g_print ("gdk_window_set_skip_taskbar_hint: %p: %s\n",
 			   GDK_WINDOW_HWND (window),
 			   skips_taskbar ? "TRUE" : "FALSE"));
Index: gdk/win32/gdkwindow-win32.h
===================================================================
--- gdk/win32/gdkwindow-win32.h	(revision 18613)
+++ gdk/win32/gdkwindow-win32.h	(working copy)
@@ -88,6 +88,9 @@
   gboolean extension_events_selected;
 
   GdkWindow *transient_owner;
+  GSList    *transient_children;
+  gint       num_transients;
+  gboolean   changing_state;
 };
  
 struct _GdkWindowImplWin32Class 
