Make sure grab-notify is emitted on toplevels as well as child widgets.

2006-05-22  Alexander Larsson  <alexl@redhat.com>

	* gtk/gtkmain.c:
	Make sure grab-notify is emitted on toplevels as well as
	child widgets.

	* gtk/Makefile.am:
	* gtk/gtkwin32embedwidget.[ch]
	Add new widget used for win32 port to embed gtk+
	widgets in windows dialog.

	* gtk/gtkmarshalers.list:
	Add POINTER:VOID

	* gtk/gtkprintoperation-private.h:
	* gtk/gtkprintoperation.[ch]:
	Generic support for custom widgets in print dialog.

	* gtk/gtkprintoperation-win32.c:
	Implement custom widget support for win32.

	* tests/print-editor.c:
	Allow setting of font using custom widgets in the print dialog.

1 files changed, 394 insertions, 0 deletions

diff --git a/gtk/gtkwin32embedwidget.c b/gtk/gtkwin32embedwidget.c
new file mode 100644
index 0000000000..ac43aaa917
--- /dev/null
+++ b/gtk/gtkwin32embedwidget.c
@@ -0,0 +1,394 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2006.  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/. 
+ */
+
+#include <config.h>
+
+#include "gtkmain.h"
+#include "gtkmarshalers.h"
+#include "gtkwin32embedwidget.h"
+#include "gtkintl.h"
+#include "gtkprivate.h"
+
+#include "gtkalias.h"
+
+static void            gtk_win32_embed_widget_realize               (GtkWidget        *widget);
+static void            gtk_win32_embed_widget_unrealize             (GtkWidget        *widget);
+static void            gtk_win32_embed_widget_show                  (GtkWidget        *widget);
+static void            gtk_win32_embed_widget_hide                  (GtkWidget        *widget);
+static void            gtk_win32_embed_widget_map                   (GtkWidget        *widget);
+static void            gtk_win32_embed_widget_unmap                 (GtkWidget        *widget);
+static void            gtk_win32_embed_widget_size_allocate         (GtkWidget        *widget,
+								     GtkAllocation    *allocation);
+static void            gtk_win32_embed_widget_set_focus             (GtkWindow        *window,
+								     GtkWidget        *focus);
+static gboolean        gtk_win32_embed_widget_focus                 (GtkWidget        *widget,
+								     GtkDirectionType  direction);
+static void            gtk_win32_embed_widget_check_resize          (GtkContainer     *container);
+
+static GtkBinClass *bin_class = NULL;
+
+G_DEFINE_TYPE (GtkWin32EmbedWidget, gtk_win32_embed_widget, GTK_TYPE_WINDOW)
+
+static void
+gtk_win32_embed_widget_class_init (GtkWin32EmbedWidgetClass *class)
+{
+  GtkWidgetClass *widget_class = (GtkWidgetClass *)class;
+  GtkWindowClass *window_class = (GtkWindowClass *)class;
+  GtkContainerClass *container_class = (GtkContainerClass *)class;
+
+  bin_class = g_type_class_peek (GTK_TYPE_BIN);
+
+  widget_class->realize = gtk_win32_embed_widget_realize;
+  widget_class->unrealize = gtk_win32_embed_widget_unrealize;
+
+  widget_class->show = gtk_win32_embed_widget_show;
+  widget_class->hide = gtk_win32_embed_widget_hide;
+  widget_class->map = gtk_win32_embed_widget_map;
+  widget_class->unmap = gtk_win32_embed_widget_unmap;
+  widget_class->size_allocate = gtk_win32_embed_widget_size_allocate;
+
+  widget_class->focus = gtk_win32_embed_widget_focus;
+  
+  container_class->check_resize = gtk_win32_embed_widget_check_resize;
+
+  window_class->set_focus = gtk_win32_embed_widget_set_focus;
+}
+
+static void
+gtk_win32_embed_widget_init (GtkWin32EmbedWidget *embed_widget)
+{
+  GtkWindow *window;
+
+  window = GTK_WINDOW (embed_widget);
+
+  window->type = GTK_WINDOW_TOPLEVEL;
+
+  GTK_WIDGET_SET_FLAGS (embed_widget, GTK_TOPLEVEL);
+  gtk_container_set_resize_mode (GTK_CONTAINER (embed_widget), GTK_RESIZE_QUEUE);
+}
+
+GtkWidget*
+_gtk_win32_embed_widget_new (GdkNativeWindow parent_id)
+{
+  GtkWin32EmbedWidget *embed_widget;
+
+  embed_widget = g_object_new (GTK_TYPE_WIN32_EMBED_WIDGET, NULL);
+  
+  embed_widget->parent_window =
+    gdk_window_lookup_for_display (gdk_display_get_default (),
+				   parent_id);
+  
+  if (!embed_widget->parent_window)
+    embed_widget->parent_window =
+      gdk_window_foreign_new_for_display (gdk_display_get_default (),
+					  parent_id);
+  
+  return GTK_WIDGET (embed_widget);
+}
+
+BOOL
+_gtk_win32_embed_widget_dialog_procedure (GtkWin32EmbedWidget *embed_widget,
+					  HWND wnd, UINT message, WPARAM wparam, LPARAM lparam)
+{
+  GtkWidget *widget = GTK_WIDGET (embed_widget);
+  
+ if (message == WM_SIZE)
+   {
+     widget->allocation.width = LOWORD(lparam);
+     widget->allocation.height = HIWORD(lparam);
+     
+     gtk_widget_queue_resize (widget);
+   }
+        
+ return 0;
+}
+
+static void
+gtk_win32_embed_widget_unrealize (GtkWidget *widget)
+{
+  GtkWin32EmbedWidget *embed_widget;
+
+  g_return_if_fail (GTK_IS_WIN32_EMBED_WIDGET (widget));
+
+  embed_widget = GTK_WIN32_EMBED_WIDGET (widget);
+
+  embed_widget->old_window_procedure = NULL;
+  
+  if (embed_widget->parent_window != NULL)
+    {
+      gdk_window_set_user_data (embed_widget->parent_window, NULL);
+      g_object_unref (embed_widget->parent_window);
+      embed_widget->parent_window = NULL;
+    }
+  
+  if (GTK_WIDGET_CLASS (gtk_win32_embed_widget_parent_class)->unrealize)
+    (* GTK_WIDGET_CLASS (gtk_win32_embed_widget_parent_class)->unrealize) (widget);
+}
+
+static LRESULT CALLBACK
+gtk_win32_embed_widget_window_process (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
+{
+  GdkWindow *window;
+  GtkWin32EmbedWidget *embed_widget;
+  gpointer user_data;
+
+  window = gdk_window_lookup ((GdkNativeWindow)hwnd);
+  if (window == NULL) {
+    g_warning ("No such window!");
+    return 0;
+  }
+  gdk_window_get_user_data (window, &user_data);
+  embed_widget = GTK_WIN32_EMBED_WIDGET (user_data);
+
+  if (msg == WM_GETDLGCODE) {
+    return DLGC_WANTALLKEYS;
+  }
+
+  if (embed_widget && embed_widget->old_window_procedure)
+    return CallWindowProc(embed_widget->old_window_procedure,
+			  hwnd, msg, wparam, lparam);
+  else
+    return 0;
+}
+
+static void
+gtk_win32_embed_widget_realize (GtkWidget *widget)
+{
+  GtkWindow *window;
+  GtkWin32EmbedWidget *embed_widget;
+  GdkWindowAttr attributes;
+  gint attributes_mask;
+  LONG_PTR styles;
+
+  g_return_if_fail (GTK_IS_WIN32_EMBED_WIDGET (widget));
+
+  window = GTK_WINDOW (widget);
+  embed_widget = GTK_WIN32_EMBED_WIDGET (widget);
+  
+  /* ensure widget tree is properly size allocated */
+  if (widget->allocation.x == -1 &&
+      widget->allocation.y == -1 &&
+      widget->allocation.width == 1 &&
+      widget->allocation.height == 1)
+    {
+      GtkRequisition requisition;
+      GtkAllocation allocation = { 0, 0, 200, 200 };
+
+      gtk_widget_size_request (widget, &requisition);
+      if (requisition.width || requisition.height)
+	{
+	  /* non-empty window */
+	  allocation.width = requisition.width;
+	  allocation.height = requisition.height;
+	}
+      gtk_widget_size_allocate (widget, &allocation);
+      
+      _gtk_container_queue_resize (GTK_CONTAINER (widget));
+
+      g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
+    }
+
+  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+
+  attributes.window_type = GDK_WINDOW_CHILD;
+  attributes.title = window->title;
+  attributes.wmclass_name = window->wmclass_name;
+  attributes.wmclass_class = window->wmclass_class;
+  attributes.width = widget->allocation.width;
+  attributes.height = widget->allocation.height;
+  attributes.wclass = GDK_INPUT_OUTPUT;
+
+  /* this isn't right - we should match our parent's visual/colormap.
+   * though that will require handling "foreign" colormaps */
+  attributes.visual = gtk_widget_get_visual (widget);
+  attributes.colormap = gtk_widget_get_colormap (widget);
+  attributes.event_mask = gtk_widget_get_events (widget);
+  attributes.event_mask |= (GDK_EXPOSURE_MASK |
+			    GDK_KEY_PRESS_MASK |
+			    GDK_KEY_RELEASE_MASK |
+			    GDK_ENTER_NOTIFY_MASK |
+			    GDK_LEAVE_NOTIFY_MASK |
+			    GDK_STRUCTURE_MASK |
+			    GDK_FOCUS_CHANGE_MASK);
+
+  attributes_mask = GDK_WA_VISUAL | GDK_WA_COLORMAP;
+  attributes_mask |= (window->title ? GDK_WA_TITLE : 0);
+  attributes_mask |= (window->wmclass_name ? GDK_WA_WMCLASS : 0);
+
+  widget->window = gdk_window_new (embed_widget->parent_window, 
+				   &attributes, attributes_mask);
+
+  gdk_window_set_user_data (widget->window, window);
+
+  embed_widget->old_window_procedure = (gpointer)
+    SetWindowLongPtrW(GDK_WINDOW_HWND (widget->window),
+		      GWLP_WNDPROC,
+		      (LONG_PTR)gtk_win32_embed_widget_window_process);
+
+  /* Enable tab to focus the widget */
+  styles = GetWindowLongPtr(GDK_WINDOW_HWND (widget->window), GWL_STYLE);
+  SetWindowLongPtrW(GDK_WINDOW_HWND (widget->window), GWL_STYLE, styles | WS_TABSTOP);
+  
+  widget->style = gtk_style_attach (widget->style, widget->window);
+  gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
+}
+
+static void
+gtk_win32_embed_widget_show (GtkWidget *widget)
+{
+  GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
+  
+  gtk_widget_realize (widget);
+  gtk_container_check_resize (GTK_CONTAINER (widget));
+  gtk_widget_map (widget);
+}
+
+static void
+gtk_win32_embed_widget_hide (GtkWidget *widget)
+{
+  GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
+  gtk_widget_unmap (widget);
+}
+
+static void
+gtk_win32_embed_widget_map (GtkWidget *widget)
+{
+  GtkBin *bin = GTK_BIN (widget);
+  
+  GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+  
+  if (bin->child &&
+      GTK_WIDGET_VISIBLE (bin->child) &&
+      !GTK_WIDGET_MAPPED (bin->child))
+    gtk_widget_map (bin->child);
+
+  gdk_window_show (widget->window);
+}
+
+static void
+gtk_win32_embed_widget_unmap (GtkWidget *widget)
+{
+  GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+  gdk_window_hide (widget->window);
+}
+
+static void
+gtk_win32_embed_widget_size_allocate (GtkWidget     *widget,
+				      GtkAllocation *allocation)
+{
+  GtkBin *bin = GTK_BIN (widget);
+  
+  widget->allocation = *allocation;
+  
+  if (GTK_WIDGET_REALIZED (widget))
+    gdk_window_move_resize (widget->window,
+			    allocation->x, allocation->y,
+			    allocation->width, allocation->height);
+  
+  if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+    {
+      GtkAllocation child_allocation;
+      
+      child_allocation.x = child_allocation.y = GTK_CONTAINER (widget)->border_width;
+      child_allocation.width =
+	MAX (1, (gint)allocation->width - child_allocation.x * 2);
+      child_allocation.height =
+	MAX (1, (gint)allocation->height - child_allocation.y * 2);
+      
+      gtk_widget_size_allocate (bin->child, &child_allocation);
+    }
+}
+
+static void
+gtk_win32_embed_widget_check_resize (GtkContainer *container)
+{
+  GTK_CONTAINER_CLASS (bin_class)->check_resize (container);
+}
+
+static gboolean
+gtk_win32_embed_widget_focus (GtkWidget        *widget,
+			      GtkDirectionType  direction)
+{
+  GtkBin *bin = GTK_BIN (widget);
+  GtkWin32EmbedWidget *embed_widget = GTK_WIN32_EMBED_WIDGET (widget);
+  GtkWindow *window = GTK_WINDOW (widget);
+  GtkContainer *container = GTK_CONTAINER (widget);
+  GtkWidget *old_focus_child = container->focus_child;
+  GtkWidget *parent;
+
+  /* We override GtkWindow's behavior, since we don't want wrapping here.
+   */
+  if (old_focus_child)
+    {
+      if (gtk_widget_child_focus (old_focus_child, direction))
+	return TRUE;
+
+      if (window->focus_widget)
+	{
+	  /* Wrapped off the end, clear the focus setting for the toplevel */
+	  parent = window->focus_widget->parent;
+	  while (parent)
+	    {
+	      gtk_container_set_focus_child (GTK_CONTAINER (parent), NULL);
+	      parent = GTK_WIDGET (parent)->parent;
+	    }
+	  
+	  gtk_window_set_focus (GTK_WINDOW (container), NULL);
+	}
+    }
+  else
+    {
+      /* Try to focus the first widget in the window */
+      if (bin->child && gtk_widget_child_focus (bin->child, direction))
+        return TRUE;
+    }
+
+  if (!GTK_CONTAINER (window)->focus_child)
+    {
+      int backwards = FALSE;
+
+      if (direction == GTK_DIR_TAB_BACKWARD ||
+	  direction == GTK_DIR_LEFT)
+	backwards = TRUE;
+      
+      PostMessage(GDK_WINDOW_HWND (embed_widget->parent_window),
+				   WM_NEXTDLGCTL,
+				   backwards, 0);
+    }
+
+  return FALSE;
+}
+
+static void
+gtk_win32_embed_widget_set_focus (GtkWindow *window,
+				  GtkWidget *focus)
+{
+  GTK_WINDOW_CLASS (gtk_win32_embed_widget_parent_class)->set_focus (window, focus);
+
+  gdk_window_focus (GTK_WIDGET(window)->window, 0);
+}
+
+#define __GTK_WIN32_EMBED_WIDGET_C__
+#include "gtkaliasdef.c"