diff options
Diffstat (limited to 'gtk/gtkwindow.c')
| -rw-r--r-- | gtk/gtkwindow.c | 1195 |
1 files changed, 1195 insertions, 0 deletions
diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c new file mode 100644 index 000000000..e97708a96 --- /dev/null +++ b/gtk/gtkwindow.c @@ -0,0 +1,1195 @@ +/* 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 Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#include <string.h> +#include <limits.h> +#include "gdk/gdk.h" +#include "gdk/gdkkeysyms.h" +#include "gdk/gdkx.h" +#include "gtksignal.h" +#include "gtkwindow.h" + +enum { + MOVE_RESIZE, + LAST_SIGNAL +}; + + +typedef gint (*GtkWindowSignal1) (GtkObject *object, + gpointer arg1, + gpointer arg2, + gint arg3, + gint arg4, + gpointer data); + + +static void gtk_window_marshal_signal_1 (GtkObject *object, + GtkSignalFunc func, + gpointer func_data, + GtkArg *args); + +static void gtk_window_class_init (GtkWindowClass *klass); +static void gtk_window_init (GtkWindow *window); +static void gtk_window_arg (GtkWindow *window, + GtkArg *arg); +static void gtk_window_destroy (GtkObject *object); +static void gtk_window_show (GtkWidget *widget); +static void gtk_window_hide (GtkWidget *widget); +static void gtk_window_map (GtkWidget *widget); +static void gtk_window_unmap (GtkWidget *widget); +static void gtk_window_realize (GtkWidget *widget); +static void gtk_window_size_request (GtkWidget *widget, + GtkRequisition *requisition); +static void gtk_window_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); +static gint gtk_window_expose_event (GtkWidget *widget, + GdkEventExpose *event); +static gint gtk_window_configure_event (GtkWidget *widget, + GdkEventConfigure *event); +static gint gtk_window_key_press_event (GtkWidget *widget, + GdkEventKey *event); +static gint gtk_window_key_release_event (GtkWidget *widget, + GdkEventKey *event); +static gint gtk_window_enter_notify_event (GtkWidget *widget, + GdkEventCrossing *event); +static gint gtk_window_leave_notify_event (GtkWidget *widget, + GdkEventCrossing *event); +static gint gtk_window_focus_in_event (GtkWidget *widget, + GdkEventFocus *event); +static gint gtk_window_focus_out_event (GtkWidget *widget, + GdkEventFocus *event); +static gint gtk_window_client_event (GtkWidget *widget, + GdkEvent *event); +static gint gtk_window_need_resize (GtkContainer *container); +static gint gtk_real_window_move_resize (GtkWindow *window, + gint *x, + gint *y, + gint width, + gint height); +static gint gtk_window_move_resize (GtkWidget *widget); +static void gtk_window_set_hints (GtkWidget *widget, + GtkRequisition *requisition); +static gint gtk_window_check_accelerator (GtkWindow *window, + gint key, + guint mods); + + +static GtkBinClass *parent_class = NULL; +static gint window_signals[LAST_SIGNAL] = { 0 }; + + +guint +gtk_window_get_type () +{ + static guint window_type = 0; + + if (!window_type) + { + GtkTypeInfo window_info = + { + "GtkWindow", + sizeof (GtkWindow), + sizeof (GtkWindowClass), + (GtkClassInitFunc) gtk_window_class_init, + (GtkObjectInitFunc) gtk_window_init, + (GtkArgFunc) gtk_window_arg, + }; + + window_type = gtk_type_unique (gtk_bin_get_type (), &window_info); + } + + return window_type; +} + +static void +gtk_window_class_init (GtkWindowClass *klass) +{ + GtkObjectClass *object_class; + GtkWidgetClass *widget_class; + GtkContainerClass *container_class; + + object_class = (GtkObjectClass*) klass; + widget_class = (GtkWidgetClass*) klass; + container_class = (GtkContainerClass*) klass; + + parent_class = gtk_type_class (gtk_bin_get_type ()); + + gtk_object_add_arg_type ("GtkWindow::type", GTK_TYPE_WINDOW_TYPE); + gtk_object_add_arg_type ("GtkWindow::title", GTK_TYPE_STRING); + gtk_object_add_arg_type ("GtkWindow::auto_shrink", GTK_TYPE_BOOL); + gtk_object_add_arg_type ("GtkWindow::allow_shrink", GTK_TYPE_BOOL); + gtk_object_add_arg_type ("GtkWindow::allow_grow", GTK_TYPE_BOOL); + + window_signals[MOVE_RESIZE] = + gtk_signal_new ("move_resize", + GTK_RUN_LAST, + object_class->type, + GTK_SIGNAL_OFFSET (GtkWindowClass, move_resize), + gtk_window_marshal_signal_1, + GTK_TYPE_BOOL, 4, + GTK_TYPE_POINTER, GTK_TYPE_POINTER, + GTK_TYPE_INT, GTK_TYPE_INT); + + gtk_object_class_add_signals (object_class, window_signals, LAST_SIGNAL); + + object_class->destroy = gtk_window_destroy; + + widget_class->show = gtk_window_show; + widget_class->hide = gtk_window_hide; + widget_class->map = gtk_window_map; + widget_class->unmap = gtk_window_unmap; + widget_class->realize = gtk_window_realize; + widget_class->size_request = gtk_window_size_request; + widget_class->size_allocate = gtk_window_size_allocate; + widget_class->expose_event = gtk_window_expose_event; + widget_class->configure_event = gtk_window_configure_event; + widget_class->key_press_event = gtk_window_key_press_event; + widget_class->key_release_event = gtk_window_key_release_event; + widget_class->enter_notify_event = gtk_window_enter_notify_event; + widget_class->leave_notify_event = gtk_window_leave_notify_event; + widget_class->focus_in_event = gtk_window_focus_in_event; + widget_class->focus_out_event = gtk_window_focus_out_event; + widget_class->client_event = gtk_window_client_event; + + container_class->need_resize = gtk_window_need_resize; + + klass->move_resize = gtk_real_window_move_resize; +} + +static void +gtk_window_init (GtkWindow *window) +{ + GTK_WIDGET_UNSET_FLAGS (window, GTK_NO_WINDOW); + GTK_WIDGET_SET_FLAGS (window, GTK_ANCHORED); + + window->title = NULL; + window->wmclass_name = NULL; + window->wmclass_class = NULL; + window->type = GTK_WINDOW_TOPLEVEL; + window->accelerator_tables = NULL; + window->focus_widget = NULL; + window->default_widget = NULL; + window->resize_count = 0; + window->need_resize = FALSE; + window->allow_shrink = FALSE; + window->allow_grow = TRUE; + window->auto_shrink = FALSE; + window->handling_resize = FALSE; + window->position = GTK_WIN_POS_NONE; + window->use_uposition = TRUE; +} + +static void +gtk_window_arg (GtkWindow *window, + GtkArg *arg) +{ + if (strcmp (arg->name, "type") == 0) + { + window->type = GTK_VALUE_ENUM(*arg); + } + else if (strcmp (arg->name, "title") == 0) + { + gtk_window_set_title (window, GTK_VALUE_STRING(*arg)); + } + else if (strcmp (arg->name, "auto_shrink") == 0) + { + window->auto_shrink = (GTK_VALUE_BOOL(*arg) != FALSE); + } + else if (strcmp (arg->name, "allow_shrink") == 0) + { + window->allow_shrink = (GTK_VALUE_BOOL(*arg) != FALSE); + } + else if (strcmp (arg->name, "allow_grow") == 0) + { + window->allow_grow = (GTK_VALUE_BOOL(*arg) != FALSE); + } +} + +GtkWidget* +gtk_window_new (GtkWindowType type) +{ + GtkWindow *window; + + window = gtk_type_new (gtk_window_get_type ()); + + window->type = type; + + return GTK_WIDGET (window); +} + +void +gtk_window_set_title (GtkWindow *window, + const gchar *title) +{ + g_return_if_fail (window != NULL); + g_return_if_fail (GTK_IS_WINDOW (window)); + + if (window->title) + g_free (window->title); + window->title = g_strdup (title); + + if (GTK_WIDGET_REALIZED (window)) + gdk_window_set_title (GTK_WIDGET (window)->window, window->title); +} + +void +gtk_window_set_wmclass (GtkWindow *window, + gchar *wmclass_name, + gchar *wmclass_class) +{ + g_return_if_fail (window != NULL); + g_return_if_fail (GTK_IS_WINDOW (window)); + + if (window->wmclass_name) + g_free (window->wmclass_name); + window->wmclass_name = g_strdup (wmclass_name); + + if (window->wmclass_class) + g_free (window->wmclass_class); + window->wmclass_class = g_strdup (wmclass_class); + + if (GTK_WIDGET_REALIZED (window)) + g_warning ("shouldn't set wmclass after window is realized!\n"); +} + +void +gtk_window_set_focus (GtkWindow *window, + GtkWidget *focus) +{ + GdkEventFocus event; + + g_return_if_fail (window != NULL); + g_return_if_fail (GTK_IS_WINDOW (window)); + + if (focus && !GTK_WIDGET_CAN_FOCUS (focus)) + return; + + if (window->focus_widget != focus) + { + if (window->focus_widget) + { + event.type = GDK_FOCUS_CHANGE; + event.window = window->focus_widget->window; + event.in = FALSE; + + gtk_widget_event (window->focus_widget, (GdkEvent*) &event); + } + + window->focus_widget = focus; + + if (window->focus_widget) + { + event.type = GDK_FOCUS_CHANGE; + event.window = window->focus_widget->window; + event.in = TRUE; + + gtk_widget_event (window->focus_widget, (GdkEvent*) &event); + } + } +} + +void +gtk_window_set_default (GtkWindow *window, + GtkWidget *defaultw) +{ + g_return_if_fail (window != NULL); + g_return_if_fail (GTK_IS_WINDOW (window)); + g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (defaultw)); + + if (window->default_widget != defaultw) + { + if (window->default_widget) + { + GTK_WIDGET_UNSET_FLAGS (window->default_widget, GTK_HAS_DEFAULT); + gtk_widget_draw_default (window->default_widget); + } + + window->default_widget = defaultw; + + if (window->default_widget) + { + GTK_WIDGET_SET_FLAGS (window->default_widget, GTK_HAS_DEFAULT); + gtk_widget_draw_default (window->default_widget); + } + } +} + +void +gtk_window_set_policy (GtkWindow *window, + gint allow_shrink, + gint allow_grow, + gint auto_shrink) +{ + g_return_if_fail (window != NULL); + g_return_if_fail (GTK_IS_WINDOW (window)); + + window->allow_shrink = (allow_shrink != FALSE); + window->allow_grow = (allow_grow != FALSE); + window->auto_shrink = (auto_shrink != FALSE); +} + +void +gtk_window_add_accelerator_table (GtkWindow *window, + GtkAcceleratorTable *table) +{ + g_return_if_fail (window != NULL); + g_return_if_fail (GTK_IS_WINDOW (window)); + + gtk_accelerator_table_ref (table); + window->accelerator_tables = g_list_prepend (window->accelerator_tables, table); +} + +void +gtk_window_remove_accelerator_table (GtkWindow *window, + GtkAcceleratorTable *table) +{ + g_return_if_fail (window != NULL); + g_return_if_fail (GTK_IS_WINDOW (window)); + + window->accelerator_tables = g_list_remove (window->accelerator_tables, table); + gtk_accelerator_table_unref (table); +} + +void +gtk_window_position (GtkWindow *window, + GtkWindowPosition position) +{ + g_return_if_fail (window != NULL); + g_return_if_fail (GTK_IS_WINDOW (window)); + + window->position = position; +} + +static void +gtk_window_marshal_signal_1 (GtkObject *object, + GtkSignalFunc func, + gpointer func_data, + GtkArg *args) +{ + GtkWindowSignal1 rfunc; + gint *return_val; + + rfunc = (GtkWindowSignal1) func; + return_val = GTK_RETLOC_BOOL (args[4]); + + *return_val = (* rfunc) (object, + GTK_VALUE_POINTER (args[0]), + GTK_VALUE_POINTER (args[1]), + GTK_VALUE_INT (args[2]), + GTK_VALUE_INT (args[3]), + func_data); +} + +static void +gtk_window_destroy (GtkObject *object) +{ + GtkWindow *window; + + g_return_if_fail (object != NULL); + g_return_if_fail (GTK_IS_WINDOW (object)); + + window = GTK_WINDOW (object); + g_free (window->title); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); +} + +static void +gtk_window_show (GtkWidget *widget) +{ + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_WINDOW (widget)); + + GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE); + gtk_widget_map (widget); +} + +static void +gtk_window_hide (GtkWidget *widget) +{ + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_WINDOW (widget)); + + GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE); + gtk_widget_unmap (widget); +} + +static void +gtk_window_map (GtkWidget *widget) +{ + GtkWindow *window; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_WINDOW (widget)); + + GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED); + GTK_WIDGET_UNSET_FLAGS (widget, GTK_UNMAPPED); + + gtk_window_move_resize (widget); + window = GTK_WINDOW (widget); + + if (window->bin.child && + GTK_WIDGET_VISIBLE (window->bin.child) && + !GTK_WIDGET_MAPPED (window->bin.child)) + gtk_widget_map (window->bin.child); + + gtk_window_set_hints (widget, &widget->requisition); + gdk_window_show (widget->window); +} + +static void +gtk_window_unmap (GtkWidget *widget) +{ + GtkWindow *window; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_WINDOW (widget)); + + GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED); + GTK_WIDGET_SET_FLAGS (widget, GTK_UNMAPPED); + gdk_window_hide (widget->window); + + window = GTK_WINDOW (widget); + window->use_uposition = TRUE; +} + +static void +gtk_window_realize (GtkWidget *widget) +{ + GtkWindow *window; + GdkWindowAttr attributes; + gint attributes_mask; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_WINDOW (widget)); + + GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); + window = GTK_WINDOW (widget); + + switch (window->type) + { + case GTK_WINDOW_TOPLEVEL: + attributes.window_type = GDK_WINDOW_TOPLEVEL; + break; + case GTK_WINDOW_DIALOG: + attributes.window_type = GDK_WINDOW_DIALOG; + break; + case GTK_WINDOW_POPUP: + attributes.window_type = GDK_WINDOW_TEMP; + break; + } + + 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; + 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_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK | + GDK_FOCUS_CHANGE_MASK | + GDK_STRUCTURE_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 (NULL, &attributes, attributes_mask); + gdk_window_set_user_data (widget->window, window); + + widget->style = gtk_style_attach (widget->style, widget->window); + gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); +} + +static void +gtk_window_size_request (GtkWidget *widget, + GtkRequisition *requisition) +{ + GtkWindow *window; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_WINDOW (widget)); + g_return_if_fail (requisition != NULL); + + window = GTK_WINDOW (widget); + + if (window->bin.child) + { + requisition->width = GTK_CONTAINER (window)->border_width * 2; + requisition->height = GTK_CONTAINER (window)->border_width * 2; + + gtk_widget_size_request (window->bin.child, &window->bin.child->requisition); + + requisition->width += window->bin.child->requisition.width; + requisition->height += window->bin.child->requisition.height; + } + else + { + if (!GTK_WIDGET_VISIBLE (window)) + window->need_resize = TRUE; + } +} + +static void +gtk_window_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + GtkWindow *window; + GtkAllocation child_allocation; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_WINDOW (widget)); + g_return_if_fail (allocation != NULL); + + window = GTK_WINDOW (widget); + widget->allocation = *allocation; + + if (window->bin.child && GTK_WIDGET_VISIBLE (window->bin.child)) + { + child_allocation.x = GTK_CONTAINER (window)->border_width; + child_allocation.y = GTK_CONTAINER (window)->border_width; + child_allocation.width = allocation->width - child_allocation.x * 2; + child_allocation.height = allocation->height - child_allocation.y * 2; + + gtk_widget_size_allocate (window->bin.child, &child_allocation); + } +} + +static gint +gtk_window_expose_event (GtkWidget *widget, + GdkEventExpose *event) +{ + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + if (!GTK_WIDGET_UNMAPPED (widget)) + GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED); + + if (GTK_WIDGET_DRAWABLE (widget)) + if (GTK_WIDGET_CLASS (parent_class)->expose_event) + return (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event); + + return FALSE; +} + +static gint +gtk_window_configure_event (GtkWidget *widget, + GdkEventConfigure *event) +{ + GtkWindow *window; + GtkAllocation allocation; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + window = GTK_WINDOW (widget); + window->handling_resize = TRUE; + + allocation.x = 0; + allocation.y = 0; + allocation.width = event->width; + allocation.height = event->height; + + gtk_widget_size_allocate (widget, &allocation); + + if (window->bin.child && + GTK_WIDGET_VISIBLE (window->bin.child) && + !GTK_WIDGET_MAPPED (window->bin.child)) + gtk_widget_map (window->bin.child); + + window->resize_count -= 1; + if (window->resize_count == 0) + { + if ((event->width != widget->requisition.width) || + (event->height != widget->requisition.height)) + { + window->resize_count += 1; + gdk_window_resize (widget->window, + widget->requisition.width, + widget->requisition.height); + } + } + else if (window->resize_count < 0) + { + window->resize_count = 0; + } + + window->handling_resize = FALSE; + + return FALSE; +} + +static gint +gtk_window_key_press_event (GtkWidget *widget, + GdkEventKey *event) +{ + GtkWindow *window; + GtkDirectionType direction = 0; + gint return_val; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + window = GTK_WINDOW (widget); + + return_val = FALSE; + if (window->focus_widget) + return_val = gtk_widget_event (window->focus_widget, (GdkEvent*) event); + + if (!return_val && gtk_window_check_accelerator (window, event->keyval, event->state)) + return_val = TRUE; + + if (!return_val) + { + switch (event->keyval) + { + case GDK_space: + if (window->focus_widget) + { + gtk_widget_activate (window->focus_widget); + return_val = TRUE; + } + break; + case GDK_Return: + case GDK_KP_Enter: + if (window->default_widget) + { + gtk_widget_activate (window->default_widget); + return_val = TRUE; + } + else if (window->focus_widget) + { + gtk_widget_activate (window->focus_widget); + return_val = TRUE; + } + break; + case GDK_Up: + case GDK_Down: + case GDK_Left: + case GDK_Right: + case GDK_Tab: + switch (event->keyval) + { + case GDK_Up: + direction = GTK_DIR_UP; + break; + case GDK_Down: + direction = GTK_DIR_DOWN; + break; + case GDK_Left: + direction = GTK_DIR_LEFT; + break; + case GDK_Right: + direction = GTK_DIR_RIGHT; + break; + case GDK_Tab: + if (event->state & GDK_SHIFT_MASK) + direction = GTK_DIR_TAB_BACKWARD; + else + direction = GTK_DIR_TAB_FORWARD; + break; + default : + direction = GTK_DIR_UP; /* never reached, but makes compiler happy */ + } + + gtk_container_focus (GTK_CONTAINER (widget), direction); + + if (!GTK_CONTAINER (window)->focus_child) + gtk_window_set_focus (GTK_WINDOW (widget), NULL); + else + return_val = TRUE; + break; + } + } + + return return_val; +} + +static gint +gtk_window_key_release_event (GtkWidget *widget, + GdkEventKey *event) +{ + GtkWindow *window; + gint return_val; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + window = GTK_WINDOW (widget); + if (window->focus_widget) + return_val = gtk_widget_event (window->focus_widget, (GdkEvent*) event); + + return return_val; +} + +static gint +gtk_window_enter_notify_event (GtkWidget *widget, + GdkEventCrossing *event) +{ + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + return FALSE; +} + +static gint +gtk_window_leave_notify_event (GtkWidget *widget, + GdkEventCrossing *event) +{ + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + return FALSE; +} + +static gint +gtk_window_focus_in_event (GtkWidget *widget, + GdkEventFocus *event) +{ + GtkWindow *window; + GdkEventFocus fevent; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + /* It appears spurious focus in events can occur when + * the window is hidden. So we'll just check to see if + * the window is visible before actually handling the + * event + */ + if (GTK_WIDGET_VISIBLE (widget)) + { + window = GTK_WINDOW (widget); + if (window->focus_widget && !GTK_WIDGET_HAS_FOCUS (window->focus_widget)) + { + fevent.type = GDK_FOCUS_CHANGE; + fevent.window = window->focus_widget->window; + fevent.in = TRUE; + + gtk_widget_event (window->focus_widget, (GdkEvent*) &fevent); + } + } + + return FALSE; +} + +static gint +gtk_window_focus_out_event (GtkWidget *widget, + GdkEventFocus *event) +{ + GtkWindow *window; + GdkEventFocus fevent; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + window = GTK_WINDOW (widget); + if (window->focus_widget && GTK_WIDGET_HAS_FOCUS (window->focus_widget)) + { + fevent.type = GDK_FOCUS_CHANGE; + fevent.window = window->focus_widget->window; + fevent.in = FALSE; + + gtk_widget_event (window->focus_widget, (GdkEvent*) &fevent); + } + + return FALSE; +} + +static void +gtk_window_style_set_event (GtkWidget *widget, + GdkEventClient *event) +{ + GdkAtom atom_default_colors; + GtkStyle *style_newdefault; + GdkAtom realtype; + gint retfmt, retlen; + GdkColor *data, *stylecolors; + int i = 0, j; + GdkColormap *widget_cmap; + + atom_default_colors = gdk_atom_intern("_GTK_DEFAULT_COLORS", FALSE); + + if(gdk_property_get (GDK_ROOT_PARENT(), + atom_default_colors, + GDK_NONE, + 0, + sizeof(GdkColor) * GTK_STYLE_NUM_STYLECOLORS(), + FALSE, + &realtype, + &retfmt, + &retlen, + (guchar *)&data) != TRUE + || retfmt != sizeof(gushort)) { + g_warning("gdk_property_get() failed in _GTK_STYLE_CHANGED\n"); + return; + } + /* We have the color data, now let's interpret it */ + style_newdefault = gtk_widget_get_default_style(); + gtk_style_ref(style_newdefault); + stylecolors = (GdkColor *) style_newdefault; + + widget_cmap = gtk_widget_get_colormap(widget); + for(i = 0; i < GTK_STYLE_NUM_STYLECOLORS(); i++) { + stylecolors[i] = data[i]; + gdk_color_alloc(widget_cmap, &stylecolors[i]); + } + + gtk_widget_set_default_style(style_newdefault); + gtk_style_unref(style_newdefault); + + /* Now we need to redraw everything */ + gtk_widget_draw(widget, NULL); + gtk_widget_draw_children(widget); +} + +static gint +gtk_window_client_event (GtkWidget *widget, + GdkEvent *event) +{ + GdkAtom atom_styleset; + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + atom_styleset = gdk_atom_intern("_GTK_STYLE_CHANGED", FALSE); + + if(event->client.message_type == atom_styleset) { + gtk_window_style_set_event(widget, event); + } + return FALSE; +} + +static gint +gtk_window_need_resize (GtkContainer *container) +{ + GtkWindow *window; + gint return_val; + + g_return_val_if_fail (container != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (container), FALSE); + + return_val = FALSE; + + window = GTK_WINDOW (container); + if (window->handling_resize) + return return_val; + + if (GTK_WIDGET_VISIBLE (container)) + { + window->need_resize = TRUE; + return_val = gtk_window_move_resize (GTK_WIDGET (window)); + window->need_resize = FALSE; + } + + return return_val; +} + +static gint +gtk_real_window_move_resize (GtkWindow *window, + gint *x, + gint *y, + gint width, + gint height) +{ + GtkWidget *widget; + GtkWidget *resize_container; + GSList *resize_widgets; + GSList *resize_containers; + GSList *tmp_list; + gint return_val; + + g_return_val_if_fail (window != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE); + g_return_val_if_fail ((x != NULL) || (y != NULL), FALSE); + + return_val = FALSE; + + widget = GTK_WIDGET (window); + + if ((*x != -1) && (*y != -1)) + gdk_window_move (widget->window, *x, *y); + + if ((widget->requisition.width == 0) || + (widget->requisition.height == 0)) + { + widget->requisition.width = 200; + widget->requisition.height = 200; + } + + gdk_window_get_geometry (widget->window, NULL, NULL, &width, &height, NULL); + + resize_containers = NULL; + + if ((window->auto_shrink && + ((width != widget->requisition.width) || + (height != widget->requisition.height))) || + (width < widget->requisition.width) || + (height < widget->requisition.height)) + { + if (window->resize_count == 0) + { + window->resize_count += 1; + gdk_window_resize (widget->window, + widget->requisition.width, + widget->requisition.height); + } + } + else + { + /* The window hasn't changed size but one of its children + * queued a resize request. Which means that the allocation + * is not sufficient for the requisition of some child. + * We've already performed a size request at this point, + * so we simply need to run through the list of resize + * widgets and reallocate their sizes appropriately. We + * make the optimization of not performing reallocation + * for a widget who also has a parent in the resize widgets + * list. + */ + resize_widgets = gtk_object_get_data (GTK_OBJECT (window), "resize_widgets"); + gtk_object_set_data (GTK_OBJECT (window), "resize_widgets", NULL); + + tmp_list = resize_widgets; + while (tmp_list) + { + widget = tmp_list->data; + tmp_list = tmp_list->next; + + /* referencing needed? */ + GTK_WIDGET_UNSET_FLAGS (widget, GTK_RESIZE_NEEDED); + gtk_object_unref (GTK_OBJECT (widget)); + + widget = widget->parent; + + while (widget && + ((widget->allocation.width < widget->requisition.width) || + (widget->allocation.height < widget->requisition.height))) + widget = widget->parent; + + if (widget) + GTK_WIDGET_SET_FLAGS (widget, GTK_RESIZE_NEEDED); + } + + tmp_list = resize_widgets; + while (tmp_list) + { + widget = tmp_list->data; + tmp_list = tmp_list->next; + + resize_container = widget->parent; + while (resize_container && + !GTK_WIDGET_RESIZE_NEEDED (resize_container)) + resize_container = resize_container->parent; + + if (resize_container) + widget = resize_container->parent; + else + widget = NULL; + + while (widget) + { + if (GTK_WIDGET_RESIZE_NEEDED (widget)) + { + GTK_WIDGET_UNSET_FLAGS (resize_container, GTK_RESIZE_NEEDED); + resize_container = widget; + } + widget = widget->parent; + } + + if (resize_container && + !g_slist_find (resize_containers, resize_container)) + resize_containers = g_slist_prepend (resize_containers, resize_container); + } + + g_slist_free (resize_widgets); + + tmp_list = resize_containers; + while (tmp_list) + { + widget = tmp_list->data; + tmp_list = tmp_list->next; + + GTK_WIDGET_UNSET_FLAGS (widget, GTK_RESIZE_NEEDED); + gtk_widget_size_allocate (widget, &widget->allocation); + gtk_widget_queue_draw (widget); + } + + g_slist_free (resize_containers); + } + + return return_val; +} + +static gint +gtk_window_move_resize (GtkWidget *widget) +{ + GtkWindow *window; + gint x, y; + gint width, height; + gint screen_width; + gint screen_height; + gint return_val; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE); + + return_val = FALSE; + + if (GTK_WIDGET_REALIZED (widget)) + { + window = GTK_WINDOW (widget); + + /* Remember old size, to know if we have to reset hints */ + width = widget->requisition.width; + height = widget->requisition.height; + gtk_widget_size_request (widget, &widget->requisition); + + if (GTK_WIDGET_MAPPED (widget) && + (width != widget->requisition.width || + height != widget->requisition.height)) + gtk_window_set_hints (widget, &widget->requisition); + + x = -1; + y = -1; + width = widget->requisition.width; + height = widget->requisition.height; + + if (window->use_uposition) + switch (window->position) + { + case GTK_WIN_POS_CENTER: + x = (gdk_screen_width () - width) / 2; + y = (gdk_screen_height () - height) / 2; + gtk_widget_set_uposition (widget, x, y); + break; + case GTK_WIN_POS_MOUSE: + gdk_window_get_pointer (NULL, &x, &y, NULL); + + x -= width / 2; + y -= height / 2; + + screen_width = gdk_screen_width (); + screen_height = gdk_screen_height (); + + if (x < 0) + x = 0; + else if (x > (screen_width - width)) + x = screen_width - width; + + if (y < 0) + y = 0; + else if (y > (screen_height - height)) + y = screen_height - height; + + gtk_widget_set_uposition (widget, x, y); + break; + } + + gtk_signal_emit (GTK_OBJECT (widget), window_signals[MOVE_RESIZE], + &x, &y, width, height, &return_val); + } + + return return_val; +} + +static void +gtk_window_set_hints (GtkWidget *widget, + GtkRequisition *requisition) +{ + GtkWindow *window; + GtkWidgetAuxInfo *aux_info; + gint flags; + gint ux, uy; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_WINDOW (widget)); + g_return_if_fail (requisition != NULL); + + if (GTK_WIDGET_REALIZED (widget)) + { + window = GTK_WINDOW (widget); + + flags = 0; + ux = 0; + uy = 0; + + aux_info = gtk_object_get_data (GTK_OBJECT (widget), "aux_info"); + if (aux_info && (aux_info->x != -1) && (aux_info->y != -1)) + { + ux = aux_info->x; + uy = aux_info->y; + flags |= GDK_HINT_POS; + } + if (!window->allow_shrink) + flags |= GDK_HINT_MIN_SIZE; + if (!window->allow_grow) + flags |= GDK_HINT_MAX_SIZE; + + gdk_window_set_hints (widget->window, ux, uy, + requisition->width, requisition->height, + requisition->width, requisition->height, + flags); + + if (window->use_uposition && (flags & GDK_HINT_POS)) + { + window->use_uposition = FALSE; + gdk_window_move (widget->window, ux, uy); + } + } +} + +static gint +gtk_window_check_accelerator (GtkWindow *window, + gint key, + guint mods) +{ + GtkAcceleratorTable *table; + GList *tmp; + + if ((key >= 0x20) && (key <= 0xFF)) + { + tmp = window->accelerator_tables; + while (tmp) + { + table = tmp->data; + tmp = tmp->next; + + if (gtk_accelerator_table_check (table, key, mods)) + return TRUE; + } + + if (gtk_accelerator_table_check (NULL, key, mods)) + return TRUE; + } + + return FALSE; +} |