X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkwindow.c;h=fe24363fd1e67ed58102b7530a2947ea08930346;hb=02e915273845b21af223e7e5e2425569afcf1b83;hp=b87c22e5f585bcb8b7c483acefd50f14409e54f5;hpb=e7a984b33762a3edd787294b012b4524cb8fd606;p=~andy%2Fgtk diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c index b87c22e5f..fe24363fd 100644 --- a/gtk/gtkwindow.c +++ b/gtk/gtkwindow.c @@ -47,6 +47,7 @@ #include "gtkwidgetprivate.h" #include "gtkcontainerprivate.h" #include "gtkintl.h" +#include "gtkstylecontextprivate.h" #include "gtktypebuiltins.h" #include "a11y/gtkwindowaccessible.h" @@ -97,6 +98,8 @@ * */ +#define AUTO_MNEMONICS_DELAY 300 /* ms */ + typedef struct _GtkDeviceGrabInfo GtkDeviceGrabInfo; struct _GtkWindowPrivate @@ -115,8 +118,6 @@ struct _GtkWindowPrivate GdkModifierType mnemonic_modifier; GdkWindowTypeHint gdk_type_hint; - gdouble opacity; - GdkWindow *grip_window; gchar *startup_id; @@ -131,6 +132,8 @@ struct _GtkWindowPrivate guint16 configure_request_count; + guint auto_mnemonics_timeout_id; + /* The following flags are initially TRUE (before a window is mapped). * They cause us to compute a configure request that involves * default-only parameters. Once mapped, we set them to FALSE. @@ -161,7 +164,6 @@ struct _GtkWindowPrivate guint mnemonics_visible_set : 1; guint focus_visible : 1; guint modal : 1; - guint opacity_set : 1; guint position : 3; guint reset_type_hint : 1; guint resizable : 1; @@ -223,7 +225,6 @@ enum { PROP_GRAVITY, PROP_TRANSIENT_FOR, PROP_ATTACHED_TO, - PROP_OPACITY, PROP_HAS_RESIZE_GRIP, PROP_RESIZE_GRIP_VISIBLE, PROP_APPLICATION, @@ -421,9 +422,11 @@ static GtkKeyHash *gtk_window_get_key_hash (GtkWindow *window); static void gtk_window_free_key_hash (GtkWindow *window); static void gtk_window_on_composited_changed (GdkScreen *screen, GtkWindow *window); +#ifdef GDK_WINDOWING_X11 static void gtk_window_on_theme_variant_changed (GtkSettings *settings, GParamSpec *pspec, GtkWindow *window); +#endif static void gtk_window_set_theme_variant (GtkWindow *window); static GSList *toplevel_list = NULL; @@ -470,14 +473,6 @@ static void gtk_window_buildable_custom_finished (GtkBuildable *buildable, const gchar *tagname, gpointer user_data); - -static void gtk_window_get_preferred_width (GtkWidget *widget, - gint *minimum_size, - gint *natural_size); -static void gtk_window_get_preferred_height (GtkWidget *widget, - gint *minimum_size, - gint *natural_size); - static void ensure_state_flag_backdrop (GtkWidget *widget); G_DEFINE_TYPE_WITH_CODE (GtkWindow, gtk_window, GTK_TYPE_BIN, @@ -590,8 +585,6 @@ gtk_window_class_init (GtkWindowClass *klass) widget_class->focus = gtk_window_focus; widget_class->move_focus = gtk_window_move_focus; widget_class->draw = gtk_window_draw; - widget_class->get_preferred_width = gtk_window_get_preferred_width; - widget_class->get_preferred_height = gtk_window_get_preferred_height; widget_class->window_state_event = gtk_window_state_event; widget_class->direction_changed = gtk_window_direction_changed; widget_class->state_changed = gtk_window_state_changed; @@ -988,24 +981,6 @@ gtk_window_class_init (GtkWindowClass *klass) GTK_TYPE_WIDGET, GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT)); - /** - * GtkWindow:opacity: - * - * The requested opacity of the window. See gtk_window_set_opacity() for - * more details about window opacity. - * - * Since: 2.12 - */ - g_object_class_install_property (gobject_class, - PROP_OPACITY, - g_param_spec_double ("opacity", - P_("Opacity for Window"), - P_("The opacity of the window, from 0 to 1"), - 0.0, - 1.0, - 1.0, - GTK_PARAM_READWRITE)); - /* Style properties. */ gtk_widget_class_install_style_property (widget_class, @@ -1143,6 +1118,7 @@ gtk_window_class_init (GtkWindowClass *klass) static void gtk_window_init (GtkWindow *window) { + GtkStyleContext *context; GtkWindowPrivate *priv; window->priv = G_TYPE_INSTANCE_GET_PRIVATE (window, @@ -1182,7 +1158,6 @@ gtk_window_init (GtkWindow *window) priv->focus_on_map = TRUE; priv->deletable = TRUE; priv->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL; - priv->opacity = 1.0; priv->startup_id = NULL; priv->initial_timestamp = GDK_CURRENT_TIME; priv->has_resize_grip = TRUE; @@ -1202,6 +1177,9 @@ gtk_window_init (GtkWindow *window) "notify::gtk-application-prefer-dark-theme", G_CALLBACK (gtk_window_on_theme_variant_changed), window); #endif + + context = gtk_widget_get_style_context (GTK_WIDGET (window)); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_BACKGROUND); } static void @@ -1301,9 +1279,6 @@ gtk_window_set_property (GObject *object, case PROP_ATTACHED_TO: gtk_window_set_attached_to (window, g_value_get_object (value)); break; - case PROP_OPACITY: - gtk_window_set_opacity (window, g_value_get_double (value)); - break; case PROP_HAS_RESIZE_GRIP: gtk_window_set_has_resize_grip (window, g_value_get_boolean (value)); break; @@ -1425,9 +1400,6 @@ gtk_window_get_property (GObject *object, case PROP_ATTACHED_TO: g_value_set_object (value, gtk_window_get_attached_to (window)); break; - case PROP_OPACITY: - g_value_set_double (value, gtk_window_get_opacity (window)); - break; case PROP_HAS_RESIZE_GRIP: g_value_set_boolean (value, priv->has_resize_grip); break; @@ -1926,8 +1898,8 @@ _gtk_window_internal_set_focus (GtkWindow *window, * unsets the default widget for a #GtkWindow about. When setting * (rather than unsetting) the default widget it's generally easier to * call gtk_widget_grab_focus() on the widget. Before making a widget - * the default widget, you must set the #GTK_CAN_DEFAULT flag on the - * widget you'd like to make the default using GTK_WIDGET_SET_FLAGS(). + * the default widget, you must call gtk_widget_set_can_default() on the + * widget you'd like to make the default. **/ void gtk_window_set_default (GtkWindow *window, @@ -2708,28 +2680,13 @@ gtk_window_get_attached_to (GtkWindow *window) * shown causes it to flicker once on Windows. * * Since: 2.12 + * Deprecated: 3.8: Use gtk_widget_set_opacity instead. **/ void gtk_window_set_opacity (GtkWindow *window, gdouble opacity) { - GtkWindowPrivate *priv; - - g_return_if_fail (GTK_IS_WINDOW (window)); - - priv = window->priv; - - if (opacity < 0.0) - opacity = 0.0; - else if (opacity > 1.0) - opacity = 1.0; - - priv->opacity_set = TRUE; - priv->opacity = opacity; - - if (gtk_widget_get_realized (GTK_WIDGET (window))) - gdk_window_set_opacity (gtk_widget_get_window (GTK_WIDGET (window)), - priv->opacity); + gtk_widget_set_opacity (GTK_WIDGET (window), opacity); } /** @@ -2742,13 +2699,14 @@ gtk_window_set_opacity (GtkWindow *window, * Return value: the requested opacity for this window. * * Since: 2.12 + * Deprecated: 3.8: Use gtk_widget_get_opacity instead. **/ gdouble gtk_window_get_opacity (GtkWindow *window) { g_return_val_if_fail (GTK_IS_WINDOW (window), 0.0); - return window->priv->opacity; + return gtk_widget_get_opacity (GTK_WIDGET (window)); } /** @@ -2819,6 +2777,9 @@ gtk_window_set_application (GtkWindow *window, gtk_application_add_window (priv->application, window); } + /* don't use a normal cast: application may be NULL */ + gtk_widget_insert_action_group (GTK_WIDGET (window), "app", (GActionGroup *) application); + g_object_notify (G_OBJECT (window), "application"); } } @@ -3400,7 +3361,7 @@ gtk_window_get_decorated (GtkWindow *window) * using this function, GTK+ will do its best to convince the window * manager not to show a close button. Depending on the system, this * function may not have any effect when called on a window that is - * already visible, so you should call it before calling gtk_window_show(). + * already visible, so you should call it before calling gtk_widget_show(). * * On Windows, this function always works, since there's no window manager * policy involved. @@ -4779,6 +4740,12 @@ gtk_window_finalize (GObject *object) g_free (priv->startup_id); + if (priv->auto_mnemonics_timeout_id) + { + g_source_remove (priv->auto_mnemonics_timeout_id); + priv->auto_mnemonics_timeout_id = 0; + } + #ifdef GDK_WINDOWING_X11 g_signal_handlers_disconnect_by_func (gtk_settings_get_default (), gtk_window_on_theme_variant_changed, @@ -4794,6 +4761,7 @@ gtk_window_show (GtkWidget *widget) GtkWindow *window = GTK_WINDOW (widget); GtkWindowPrivate *priv = window->priv; GtkContainer *container = GTK_CONTAINER (window); + GtkBitmask *empty; gboolean need_resize; gboolean is_plug; @@ -4805,8 +4773,14 @@ gtk_window_show (GtkWidget *widget) _gtk_widget_set_visible_flag (widget, TRUE); - need_resize = _gtk_container_get_need_resize (container) || !gtk_widget_get_realized (widget); - _gtk_container_set_need_resize (container, FALSE); + need_resize = _gtk_widget_get_alloc_needed (widget) || !gtk_widget_get_realized (widget); + + empty = _gtk_bitmask_new (); + _gtk_style_context_validate (gtk_widget_get_style_context (widget), + g_get_monotonic_time (), + 0, + empty); + _gtk_bitmask_free (empty); if (need_resize) { @@ -5013,8 +4987,6 @@ gtk_window_map (GtkWidget *widget) gtk_window_set_focus_visible (window, gtk_window_get_focus_visible (priv->transient_parent)); else gtk_window_set_focus_visible (window, visible_focus == GTK_POLICY_ALWAYS); - - ensure_state_flag_backdrop (widget); } static gboolean @@ -5190,11 +5162,10 @@ gtk_window_realize (GtkWidget *widget) gdk_window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask); gtk_widget_set_window (widget, gdk_window); - gdk_window_set_user_data (gdk_window, widget); + gtk_widget_register_window (widget, gdk_window); gtk_style_context_set_background (gtk_widget_get_style_context (widget), gdk_window); - gdk_window_enable_synchronized_configure (gdk_window); return; } @@ -5268,12 +5239,7 @@ gtk_window_realize (GtkWidget *widget) gdk_window = gdk_window_new (parent_window, &attributes, attributes_mask); gtk_widget_set_window (widget, gdk_window); - if (priv->opacity_set) - gdk_window_set_opacity (gdk_window, priv->opacity); - - gdk_window_enable_synchronized_configure (gdk_window); - - gdk_window_set_user_data (gdk_window, window); + gtk_widget_register_window (widget, gdk_window); context = gtk_widget_get_style_context (widget); gtk_style_context_set_background (context, gdk_window); @@ -5613,7 +5579,6 @@ gtk_window_configure_event (GtkWidget *widget, if (GTK_WIDGET_CLASS (gtk_window_parent_class)->configure_event) return GTK_WIDGET_CLASS (gtk_window_parent_class)->configure_event (widget, event); - gdk_window_configure_finished (gtk_widget_get_window (widget)); return FALSE; } @@ -5647,13 +5612,11 @@ gtk_window_configure_event (GtkWidget *widget, (allocation.width == event->width && allocation.height == event->height)) { - gdk_window_configure_finished (gtk_widget_get_window (widget)); return TRUE; } /* * If we do need to resize, we do that by: - * - filling in widget->allocation with the new size * - setting configure_notify_received to TRUE * for use in gtk_window_move_resize() * - queueing a resize, leading to invocation of @@ -5663,10 +5626,6 @@ gtk_window_configure_event (GtkWidget *widget, priv->configure_notify_received = TRUE; - allocation.width = event->width; - allocation.height = event->height; - gtk_widget_set_allocation (widget, &allocation); - gdk_window_invalidate_rect (gtk_widget_get_window (widget), NULL, FALSE); // XXX - What was this for again? _gtk_container_queue_resize (GTK_CONTAINER (widget)); @@ -5722,7 +5681,6 @@ gtk_window_style_updated (GtkWidget *widget) rect.width, rect.height); set_grip_shape (window); - gtk_widget_queue_resize (widget); } } @@ -5761,7 +5719,7 @@ resize_grip_create_window (GtkWindow *window) attributes_mask); gdk_window_set_background_rgba (priv->grip_window, &transparent); - gdk_window_set_user_data (priv->grip_window, widget); + gtk_widget_register_window (widget, priv->grip_window); gdk_window_raise (priv->grip_window); @@ -5774,7 +5732,7 @@ resize_grip_destroy_window (GtkWindow *window) { GtkWindowPrivate *priv = window->priv; - gdk_window_set_user_data (priv->grip_window, NULL); + gtk_widget_unregister_window (GTK_WIDGET (window), priv->grip_window); gdk_window_destroy (priv->grip_window); priv->grip_window = NULL; update_grip_visibility (window); @@ -6225,7 +6183,7 @@ maybe_set_mnemonics_visible (GtkWindow *window) NULL, &mask); if (window->priv->mnemonic_modifier == (mask & gtk_accelerator_get_default_mod_mask ())) { - gtk_window_set_mnemonics_visible (window, TRUE); + _gtk_window_set_auto_mnemonics_visible (window); break; } } @@ -6467,60 +6425,6 @@ gtk_window_real_set_focus (GtkWindow *window, } } - -static void -gtk_window_get_preferred_width (GtkWidget *widget, - gint *minimum_size, - gint *natural_size) -{ - GtkWindow *window; - GtkWidget *child; - guint border_width; - - window = GTK_WINDOW (widget); - child = gtk_bin_get_child (GTK_BIN (window)); - - border_width = gtk_container_get_border_width (GTK_CONTAINER (window)); - *minimum_size = border_width * 2; - *natural_size = border_width * 2; - - if (child && gtk_widget_get_visible (child)) - { - gint child_min, child_nat; - gtk_widget_get_preferred_width (child, &child_min, &child_nat); - - *minimum_size += child_min; - *natural_size += child_nat; - } -} - -static void -gtk_window_get_preferred_height (GtkWidget *widget, - gint *minimum_size, - gint *natural_size) -{ - GtkWindow *window; - GtkWidget *child; - guint border_width; - - window = GTK_WINDOW (widget); - child = gtk_bin_get_child (GTK_BIN (window)); - - border_width = gtk_container_get_border_width (GTK_CONTAINER (window)); - *minimum_size = border_width * 2; - *natural_size = border_width * 2; - - if (child && gtk_widget_get_visible (child)) - { - gint child_min, child_nat; - gtk_widget_get_preferred_height (child, &child_min, &child_nat); - - *minimum_size += child_min; - *natural_size += child_nat; - } -} - - /** * _gtk_window_unset_focus_and_default: * @window: a #GtkWindow @@ -7218,7 +7122,10 @@ gtk_window_move_resize (GtkWindow *window) &new_geometry, new_flags); - gtk_widget_get_allocation (widget, &allocation); + allocation.x = 0; + allocation.y = 0; + allocation.width = gdk_window_get_width (gdk_window); + allocation.height = gdk_window_get_height (gdk_window); /* handle resizing/moving and widget tree allocation */ @@ -7243,10 +7150,6 @@ gtk_window_move_resize (GtkWindow *window) set_grip_position (window); update_grip_visibility (window); - gdk_window_process_updates (gdk_window, TRUE); - - gdk_window_configure_finished (gdk_window); - /* If the configure request changed, it means that * we either: * 1) coincidentally changed hints or widget properties @@ -7656,14 +7559,9 @@ gtk_window_draw (GtkWidget *widget, if (!gtk_widget_get_app_paintable (widget) && gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget))) { - gtk_style_context_save (context); - - gtk_style_context_add_class (context, GTK_STYLE_CLASS_BACKGROUND); gtk_render_background (context, cr, 0, 0, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); - - gtk_style_context_restore (context); } if (GTK_WIDGET_CLASS (gtk_window_parent_class)->draw) @@ -7680,6 +7578,7 @@ gtk_window_draw (GtkWidget *widget, gtk_cairo_transform_to_window (cr, widget, priv->grip_window); gtk_window_get_resize_grip_area (GTK_WINDOW (widget), &rect); + gtk_style_context_remove_class (context, GTK_STYLE_CLASS_BACKGROUND); gtk_style_context_add_class (context, GTK_STYLE_CLASS_GRIP); gtk_style_context_set_junction_sides (context, get_grip_junction (widget)); gtk_render_handle (context, cr, 0, 0, rect.width, rect.height); @@ -8196,7 +8095,7 @@ gtk_window_set_resizable (GtkWindow *window, if (priv->resizable != resizable) { - priv->resizable = (resizable != FALSE); + priv->resizable = resizable; update_grip_visibility (window); @@ -8439,6 +8338,7 @@ gtk_window_set_theme_variant (GtkWindow *window) #endif } +#ifdef GDK_WINDOWING_X11 static void gtk_window_on_theme_variant_changed (GtkSettings *settings, GParamSpec *pspec, @@ -8447,6 +8347,7 @@ gtk_window_on_theme_variant_changed (GtkSettings *settings, if (window->priv->type == GTK_WINDOW_TOPLEVEL) gtk_window_set_theme_variant (window); } +#endif static void gtk_window_on_composited_changed (GdkScreen *screen, @@ -9570,8 +9471,8 @@ _gtk_window_set_is_active (GtkWindow *window, * in-process, parented GtkPlug) * * Internal function used by #GtkPlug when it gets parented/unparented by a - * #GtkSocket. This keeps the @window's #GTK_TOPLEVEL flag in sync with the - * global list of toplevel windows. + * #GtkSocket. This keeps the @window's #GTK_WINDOW_TOPLEVEL flag in sync + * with the global list of toplevel windows. */ void _gtk_window_set_is_toplevel (GtkWindow *window, @@ -9749,9 +9650,39 @@ gtk_window_set_mnemonics_visible (GtkWindow *window, g_object_notify (G_OBJECT (window), "mnemonics-visible"); } + if (priv->auto_mnemonics_timeout_id) + { + g_source_remove (priv->auto_mnemonics_timeout_id); + priv->auto_mnemonics_timeout_id = 0; + } + priv->mnemonics_visible_set = TRUE; } +static gboolean +set_auto_mnemonics_visible_cb (gpointer data) +{ + GtkWindow *window = data; + + gtk_window_set_mnemonics_visible (window, TRUE); + + window->priv->auto_mnemonics_timeout_id = 0; + + return FALSE; +} + +void +_gtk_window_set_auto_mnemonics_visible (GtkWindow *window) +{ + g_return_if_fail (GTK_IS_WINDOW (window)); + + if (window->priv->auto_mnemonics_timeout_id) + return; + + window->priv->auto_mnemonics_timeout_id = + gdk_threads_add_timeout (AUTO_MNEMONICS_DELAY, set_auto_mnemonics_visible_cb, window); +} + /** * gtk_window_get_focus_visible: * @window: a #GtkWindow @@ -9816,7 +9747,7 @@ _gtk_window_get_wmclass (GtkWindow *window, * @setting: the new value * * Tells GTK+ whether to drop its extra reference to the window - * when gtk_window_destroy() is called. + * when gtk_widget_destroy() is called. * * This function is only exported for the benefit of language * bindings which may need to keep the window alive until their