/* 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_is_toplevel (GTK_WIDGET (embed_widget), TRUE); 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 = 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; } 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 = GTK_WINDOW (widget); GtkWin32EmbedWidget *embed_widget = GTK_WIN32_EMBED_WIDGET (widget); GdkWindowAttr attributes; gint attributes_mask; LONG_PTR styles; /* 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_get_realized (widget)); } gtk_widget_set_realized (widget, TRUE); 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); GtkWidget *child; gtk_widget_set_mapped (widget, TRUE); child = gtk_bin_get_child (bin); if (child && gtk_widget_get_visible (child) && !gtk_widget_get_mapped (child)) gtk_widget_map (child); gdk_window_show (widget->window); } static void gtk_win32_embed_widget_unmap (GtkWidget *widget) { gtk_widget_set_mapped (widget, FALSE); gdk_window_hide (widget->window); } static void gtk_win32_embed_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { GtkBin *bin = GTK_BIN (widget); GtkWidget *child; widget->allocation = *allocation; if (gtk_widget_get_realized (widget)) gdk_window_move_resize (widget->window, allocation->x, allocation->y, allocation->width, allocation->height); child = gtk_bin_get_child (bin); if (child && gtk_widget_get_visible (child)) { GtkAllocation child_allocation; child_allocation.x = gtk_container_get_border_width (GTK_CONTAINER (widget)); child_allocation.y = child_allocation.x; 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 (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 = gtk_container_get_focus_child (container); GtkWidget *parent; GtkWidget *child; /* 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 */ child = gtk_bin_get_child (bin); if (child && gtk_widget_child_focus (child, direction)) return TRUE; } if (!gtk_container_get_focus_child (GTK_CONTAINER (window))) { 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"