PROP_DECORATED,
PROP_DELETABLE,
PROP_GRAVITY,
+ PROP_TRANSIENT_FOR,
/* Readonly properties */
PROP_IS_ACTIVE,
guint accept_focus : 1;
guint focus_on_map : 1;
guint deletable : 1;
+ guint transient_parent_group : 1;
+
+ guint reset_type_hint : 1;
+ GdkWindowTypeHint type_hint;
};
-static void gtk_window_class_init (GtkWindowClass *klass);
-static void gtk_window_init (GtkWindow *window);
static void gtk_window_dispose (GObject *object);
static void gtk_window_destroy (GtkObject *object);
static void gtk_window_finalize (GObject *object);
static void gtk_window_notify_keys_changed (GtkWindow *window);
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);
static GSList *toplevel_list = NULL;
-static GtkBinClass *parent_class = NULL;
static guint window_signals[LAST_SIGNAL] = { 0 };
static GList *default_icon_list = NULL;
static gchar *default_icon_name = NULL;
static gboolean disable_startup_notification = FALSE;
static gboolean sent_startup_notification = FALSE;
+static GQuark quark_gtk_embedded = 0;
+static GQuark quark_gtk_window_key_hash = 0;
+static GQuark quark_gtk_window_default_icon_pixmap = 0;
+static GQuark quark_gtk_window_icon_info = 0;
+
static void gtk_window_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
-GType
-gtk_window_get_type (void)
-{
- static GType window_type = 0;
-
- if (!window_type)
- {
- static const GTypeInfo window_info =
- {
- sizeof (GtkWindowClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) gtk_window_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GtkWindow),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gtk_window_init,
- };
-
- window_type = g_type_register_static (GTK_TYPE_BIN, I_("GtkWindow"),
- &window_info, 0);
- }
-
- return window_type;
-}
+G_DEFINE_TYPE (GtkWindow, gtk_window, GTK_TYPE_BIN)
static void
add_tab_bindings (GtkBindingSet *binding_set,
widget_class = (GtkWidgetClass*) klass;
container_class = (GtkContainerClass*) klass;
- parent_class = g_type_class_peek_parent (klass);
+ quark_gtk_embedded = g_quark_from_static_string ("gtk-embedded");
+ quark_gtk_window_key_hash = g_quark_from_static_string ("gtk-window-key-hash");
+ quark_gtk_window_default_icon_pixmap = g_quark_from_static_string ("gtk-window-default-icon-pixmap");
+ quark_gtk_window_icon_info = g_quark_from_static_string ("gtk-window-icon-info");
gobject_class->dispose = gtk_window_dispose;
gobject_class->finalize = gtk_window_finalize;
GDK_GRAVITY_NORTH_WEST,
GTK_PARAM_READWRITE));
+
+ /**
+ * GtkWindow:transient-for:
+ *
+ * The transient parent of the window. See gtk_window_set_transient_for() for
+ * more details about transient windows.
+ *
+ * Since: 2.10
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TRANSIENT_FOR,
+ g_param_spec_object ("transient-for",
+ P_("Transient for Window"),
+ P_("The transient parent of the dialog"),
+ GTK_TYPE_WINDOW,
+ GTK_PARAM_READWRITE| G_PARAM_CONSTRUCT));
+
window_signals[SET_FOCUS] =
g_signal_new (I_("set_focus"),
G_TYPE_FROM_CLASS (gobject_class),
priv->accept_focus = TRUE;
priv->focus_on_map = TRUE;
priv->deletable = TRUE;
+ priv->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
colormap = _gtk_widget_peek_colormap ();
if (colormap)
gtk_widget_set_colormap (GTK_WIDGET (window), colormap);
- g_object_ref (window);
- gtk_object_sink (GTK_OBJECT (window));
+ g_object_ref_sink (window);
window->has_user_ref_count = TRUE;
toplevel_list = g_slist_prepend (toplevel_list, window);
gtk_decorated_window_init (window);
- g_signal_connect (window,
- "event",
- G_CALLBACK (gtk_window_event),
- NULL);
+ g_signal_connect (window->screen, "composited_changed",
+ G_CALLBACK (gtk_window_on_composited_changed), window);
}
static void
case PROP_GRAVITY:
gtk_window_set_gravity (window, g_value_get_enum (value));
break;
+ case PROP_TRANSIENT_FOR:
+ gtk_window_set_transient_for (window, g_value_get_object (value));
+ break;
default:
break;
}
GParamSpec *pspec)
{
GtkWindow *window;
+ GtkWindowPrivate *priv;
window = GTK_WINDOW (object);
-
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
switch (prop_id)
{
GtkWindowGeometryInfo *info;
g_value_set_boolean (value, window->has_toplevel_focus);
break;
case PROP_TYPE_HINT:
- g_value_set_enum (value,
- window->type_hint);
+ g_value_set_enum (value, priv->type_hint);
break;
case PROP_SKIP_TASKBAR_HINT:
g_value_set_boolean (value,
case PROP_GRAVITY:
g_value_set_enum (value, gtk_window_get_gravity (window));
break;
+ case PROP_TRANSIENT_FOR:
+ g_value_set_object (value, gtk_window_get_transient_for (window));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
{
GtkWindow *window;
- GDK_THREADS_ENTER ();
window = GTK_WINDOW (data);
if (window->keys_changed_handler)
}
g_signal_emit (window, window_signals[KEYS_CHANGED], 0);
- GDK_THREADS_LEAVE ();
return FALSE;
}
gtk_window_notify_keys_changed (GtkWindow *window)
{
if (!window->keys_changed_handler)
- window->keys_changed_handler = g_idle_add (handle_keys_changed, window);
+ window->keys_changed_handler = gdk_threads_add_idle (handle_keys_changed, window);
}
/**
g_return_if_fail (GTK_IS_WINDOW (window));
- embedded_windows = g_object_get_data (G_OBJECT (window), "gtk-embedded");
+ embedded_windows = g_object_get_qdata (G_OBJECT (window), quark_gtk_embedded);
if (embedded_windows)
- g_object_steal_qdata (G_OBJECT (window),
- g_quark_from_static_string ("gtk-embedded"));
+ g_object_steal_qdata (G_OBJECT (window), quark_gtk_embedded);
embedded_windows = g_list_prepend (embedded_windows,
GUINT_TO_POINTER (xid));
- g_object_set_data_full (G_OBJECT (window), I_("gtk-embedded"),
- embedded_windows,
- embedded_windows ?
- (GDestroyNotify) g_list_free : NULL);
+ g_object_set_qdata_full (G_OBJECT (window), quark_gtk_embedded,
+ embedded_windows,
+ embedded_windows ?
+ (GDestroyNotify) g_list_free : NULL);
}
void
g_return_if_fail (GTK_IS_WINDOW (window));
- embedded_windows = g_object_get_data (G_OBJECT (window), "gtk-embedded");
+ embedded_windows = g_object_get_qdata (G_OBJECT (window), quark_gtk_embedded);
if (embedded_windows)
- g_object_steal_qdata (G_OBJECT (window),
- g_quark_from_static_string ("gtk-embedded"));
+ g_object_steal_qdata (G_OBJECT (window), quark_gtk_embedded);
node = g_list_find (embedded_windows, GUINT_TO_POINTER (xid));
if (node)
g_list_free_1 (node);
}
- g_object_set_data_full (G_OBJECT (window), I_("gtk-embedded"),
- embedded_windows,
- embedded_windows ?
- (GDestroyNotify) g_list_free : NULL);
+ g_object_set_qdata_full (G_OBJECT (window), quark_gtk_embedded,
+ embedded_windows,
+ embedded_windows ?
+ (GDestroyNotify) g_list_free : NULL);
}
void
gtk_window_set_focus (window, NULL);
gtk_window_set_default (window, NULL);
- G_OBJECT_CLASS (parent_class)->dispose (object);
+ G_OBJECT_CLASS (gtk_window_parent_class)->dispose (object);
}
static void
static void
gtk_window_unset_transient_for (GtkWindow *window)
{
+ GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
+
if (window->transient_parent)
{
- if (window->transient_parent->group)
- gtk_window_group_remove_window (window->transient_parent->group,
+ if (priv->transient_parent_group)
+ gtk_window_group_remove_window (window->group,
window);
g_signal_handlers_disconnect_by_func (window->transient_parent,
disconnect_parent_destroyed (window);
window->transient_parent = NULL;
+ priv->transient_parent_group = FALSE;
}
}
gtk_window_set_transient_for (GtkWindow *window,
GtkWindow *parent)
{
+ GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
+
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
g_return_if_fail (window != parent);
-
if (window->transient_parent)
{
if (GTK_WIDGET_REALIZED (window) &&
}
window->transient_parent = parent;
-
+
if (parent)
{
g_signal_connect (parent, "destroy",
GTK_WIDGET (window));
if (parent->group)
- gtk_window_group_add_window (parent->group, window);
+ {
+ gtk_window_group_add_window (parent->group, window);
+ priv->transient_parent_group = TRUE;
+ }
}
}
gtk_window_set_type_hint (GtkWindow *window,
GdkWindowTypeHint hint)
{
+ GtkWindowPrivate *priv;
+
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (!GTK_WIDGET_VISIBLE (window));
- window->type_hint = hint;
+
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ if (hint < GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU)
+ window->type_hint = hint;
+ else
+ window->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
+
+ priv->reset_type_hint = TRUE;
+ priv->type_hint = hint;
}
/**
GdkWindowTypeHint
gtk_window_get_type_hint (GtkWindow *window)
{
+ GtkWindowPrivate *priv;
+
g_return_val_if_fail (GTK_IS_WINDOW (window), GDK_WINDOW_TYPE_HINT_NORMAL);
- return window->type_hint;
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ return priv->type_hint;
}
/**
}
/**
+ * gtk_window_set_deletable:
* @window: a #GtkWindow
* @setting: %TRUE to decorate the window as deletable
*
* via gtk_window_set_deletable().
*
* Return value: %TRUE if the window has been set to have a close button
+ *
+ * Since: 2.10
**/
gboolean
gtk_window_get_deletable (GtkWindow *window)
static GtkWindowIconInfo*
get_icon_info (GtkWindow *window)
{
- return g_object_get_data (G_OBJECT (window),
- "gtk-window-icon-info");
+ return g_object_get_qdata (G_OBJECT (window), quark_gtk_window_icon_info);
}
static void
free_icon_info (GtkWindowIconInfo *info)
{
g_free (info->icon_name);
- g_free (info);
+ g_slice_free (GtkWindowIconInfo, info);
}
if (info == NULL)
{
- info = g_new0 (GtkWindowIconInfo, 1);
- g_object_set_data_full (G_OBJECT (window),
- I_("gtk-window-icon-info"),
+ info = g_slice_new0 (GtkWindowIconInfo);
+ g_object_set_qdata_full (G_OBJECT (window),
+ quark_gtk_window_icon_info,
info,
(GDestroyNotify)free_icon_info);
}
static ScreenIconInfo *
get_screen_icon_info (GdkScreen *screen)
{
- ScreenIconInfo *info = g_object_get_data (G_OBJECT (screen),
- "gtk-window-default-icon-pixmap");
+ ScreenIconInfo *info = g_object_get_qdata (G_OBJECT (screen),
+ quark_gtk_window_default_icon_pixmap);
if (!info)
{
- info = g_new0 (ScreenIconInfo, 1);
- g_object_set_data (G_OBJECT (screen), I_("gtk-window-default-icon-pixmap"), info);
+ info = g_slice_new0 (ScreenIconInfo);
+ g_object_set_qdata (G_OBJECT (screen),
+ quark_gtk_window_default_icon_pixmap, info);
}
if (info->serial != default_icon_serial)
* reference point. So, to place a window in the bottom right corner
* you would first set gravity to south east, then write:
* <literal>gtk_window_move (window, gdk_screen_width () - window_width,
- * gdk_screen_height () - window_height)</literal>.
+ * gdk_screen_height () - window_height)</literal> (note that this
+ * example does not take multi-head scenarios into account).
*
* The Extended Window Manager Hints specification at <ulink
* url="http://www.freedesktop.org/Standards/wm-spec">
* nice table of gravities in the "implementation notes" section.
*
* The gtk_window_get_position() documentation may also be relevant.
- *
- **/
+ */
void
gtk_window_move (GtkWindow *window,
gint x,
gtk_window_free_key_hash (window);
- GTK_OBJECT_CLASS (parent_class)->destroy (object);
+ GTK_OBJECT_CLASS (gtk_window_parent_class)->destroy (object);
}
static void
window->keys_changed_handler = 0;
}
- G_OBJECT_CLASS (parent_class)->finalize (object);
+ if (window->screen)
+ {
+ g_signal_handlers_disconnect_by_func (window->screen,
+ gtk_window_on_composited_changed, window);
+ }
+
+ G_OBJECT_CLASS (gtk_window_parent_class)->finalize (object);
}
static void
window->need_default_size = FALSE;
window->need_default_position = FALSE;
+ if (priv->reset_type_hint)
+ {
+ /* We should only reset the type hint when the application
+ * used gtk_window_set_type_hint() to change the hint.
+ * Some applications use X directly to change the properties;
+ * in that case, we shouldn't overwrite what they did.
+ */
+ gdk_window_set_type_hint (widget->window, priv->type_hint);
+ priv->reset_type_hint = FALSE;
+ }
+
gdk_window_show (widget->window);
if (window->frame)
}
state = gdk_window_get_state (widget->window);
- window->iconify_initially = state & GDK_WINDOW_STATE_ICONIFIED;
- window->maximize_initially = state & GDK_WINDOW_STATE_MAXIMIZED;
- window->stick_initially = state & GDK_WINDOW_STATE_STICKY;
- priv->above_initially = state & GDK_WINDOW_STATE_ABOVE;
- priv->below_initially = state & GDK_WINDOW_STATE_BELOW;
+ window->iconify_initially = (state & GDK_WINDOW_STATE_ICONIFIED) != 0;
+ window->maximize_initially = (state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
+ window->stick_initially = (state & GDK_WINDOW_STATE_STICKY) != 0;
+ priv->above_initially = (state & GDK_WINDOW_STATE_ABOVE) != 0;
+ priv->below_initially = (state & GDK_WINDOW_STATE_BELOW) != 0;
}
static void
attributes_mask = GDK_WA_X | GDK_WA_Y;
parent_window = window->frame;
+
+ g_signal_connect (window,
+ "event",
+ G_CALLBACK (gtk_window_event),
+ NULL);
}
else
{
if (!priv->deletable)
gdk_window_set_functions (widget->window, GDK_FUNC_ALL | GDK_FUNC_CLOSE);
- gdk_window_set_type_hint (widget->window, window->type_hint);
-
+ gdk_window_set_type_hint (widget->window, priv->type_hint);
+
if (gtk_window_get_skip_pager_hint (window))
gdk_window_set_skip_pager_hint (widget->window, TRUE);
/* Icons */
gtk_window_unrealize_icon (window);
- (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
+ (* GTK_WIDGET_CLASS (gtk_window_parent_class)->unrealize) (widget);
}
static void
/* Chain up, invokes binding set */
if (!handled)
- handled = GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event);
+ handled = GTK_WIDGET_CLASS (gtk_window_parent_class)->key_press_event (widget, event);
return handled;
}
/* Chain up, invokes binding set */
if (!handled)
- handled = GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event);
+ handled = GTK_WIDGET_CLASS (gtk_window_parent_class)->key_release_event (widget, event);
return handled;
}
{
GList *embedded_windows;
- embedded_windows = g_object_get_data (G_OBJECT (widget), "gtk-embedded");
+ embedded_windows = g_object_get_qdata (G_OBJECT (widget), quark_gtk_embedded);
if (embedded_windows)
{
GdkEvent *send_event = gdk_event_new (GDK_CLIENT_EVENT);
{
gint base_width = 0;
gint base_height = 0;
+ gint min_width = 0;
+ gint min_height = 0;
gint width_inc = 1;
gint height_inc = 1;
base_width = geometry.base_width;
base_height = geometry.base_height;
}
- else if (flags & GDK_HINT_MIN_SIZE)
+ if (flags & GDK_HINT_MIN_SIZE)
{
- base_width = geometry.min_width;
- base_height = geometry.min_height;
+ min_width = geometry.min_width;
+ min_height = geometry.min_height;
}
if (flags & GDK_HINT_RESIZE_INC)
{
}
if (info->default_width > 0)
- *width = info->default_width * width_inc + base_width;
+ *width = MAX (info->default_width * width_inc + base_width, min_width);
if (info->default_height > 0)
- *height = info->default_height * height_inc + base_height;
+ *height = MAX (info->default_height * height_inc + base_height, min_height);
}
}
else
parent_widget = (GtkWidget*) window->transient_parent;
pos = get_effective_position (window);
- info = gtk_window_get_geometry_info (window, TRUE);
-
- /* by default, don't change position requested */
- x = info->last.configure_request.x;
- y = info->last.configure_request.y;
+ info = gtk_window_get_geometry_info (window, FALSE);
+ /* by default, don't change position requested */
+ if (info)
+ {
+ x = info->last.configure_request.x;
+ y = info->last.configure_request.y;
+ }
+ else
+ {
+ x = 0;
+ y = 0;
+ }
+
+
if (window->need_default_position)
{
}
} /* if (window->need_default_position) */
- if (window->need_default_position &&
+ if (window->need_default_position && info &&
info->initial_pos_set)
{
x = info->initial_x;
allocation = widget->allocation;
gtk_widget_size_allocate (widget, &allocation);
- gdk_window_process_all_updates ();
+ gdk_window_process_updates (widget->window, TRUE);
gdk_window_configure_finished (widget->window);
if (!GTK_WIDGET_APP_PAINTABLE (widget))
gtk_window_paint (widget, &event->area);
- if (GTK_WIDGET_CLASS (parent_class)->expose_event)
- return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
+ if (GTK_WIDGET_CLASS (gtk_window_parent_class)->expose_event)
+ return GTK_WIDGET_CLASS (gtk_window_parent_class)->expose_event (widget, event);
return FALSE;
}
* frame_event you can receive all events targeted at the frame.
*
* This function is used by the linux-fb port to implement managed
- * windows, but it could concievably be used by X-programs that
+ * windows, but it could conceivably be used by X-programs that
* want to do their own window decorations.
*
**/
* where the user can see it.
*
* If you are calling this function in response to a user interaction,
- * it is preferable to use gdk_window_present_with_time().
+ * it is preferable to use gtk_window_present_with_time().
*
**/
void
widget = GTK_WIDGET (window);
priv = GTK_WINDOW_GET_PRIVATE (window);
- priv->above_initially = setting;
+ priv->above_initially = setting != FALSE;
if (setting)
priv->below_initially = FALSE;
widget = GTK_WIDGET (window);
priv = GTK_WINDOW_GET_PRIVATE (window);
- priv->below_initially = setting;
+ priv->below_initially = setting != FALSE;
if (setting)
priv->above_initially = FALSE;
window->screen = screen;
gtk_widget_reset_rc_styles (widget);
if (screen != previous_screen)
- _gtk_widget_propagate_screen_changed (widget, previous_screen);
+ {
+ g_signal_handlers_disconnect_by_func (previous_screen,
+ gtk_window_on_composited_changed, window);
+ g_signal_connect (screen, "composited_changed",
+ G_CALLBACK (gtk_window_on_composited_changed), window);
+
+ _gtk_widget_propagate_screen_changed (widget, previous_screen);
+ _gtk_widget_propagate_composited_changed (widget);
+ }
g_object_notify (G_OBJECT (window), "screen");
if (was_mapped)
gtk_widget_map (widget);
}
+static void
+gtk_window_on_composited_changed (GdkScreen *screen,
+ GtkWindow *window)
+{
+ gtk_widget_queue_draw (GTK_WIDGET (window));
+
+ _gtk_widget_propagate_composited_changed (GTK_WIDGET (window));
+}
+
static GdkScreen *
gtk_window_check_screen (GtkWindow *window)
{
if (!window_group_type)
{
- static const GTypeInfo window_group_info =
+ const GTypeInfo window_group_info =
{
sizeof (GtkWindowGroupClass),
NULL, /* base_init */
if (window->group)
gtk_window_group_remove_window (window->group, window);
else
- window_group_cleanup_grabs (_gtk_window_get_group (NULL), window);
+ window_group_cleanup_grabs (gtk_window_get_group (NULL), window);
window->group = window_group;
g_object_unref (window);
}
-/* Return the group for the window or the default group
+/**
+ * gtk_window_get_group:
+ * @window: a #GtkWindow, or %NULL
+ *
+ * Returns the group for @window or the default group, if
+ * @window is %NULL or if @window does not have an explicit
+ * window group.
+ *
+ * Returns: the #GtkWindowGroup for a window or the default group
+ *
+ * Since: 2.10
*/
GtkWindowGroup *
-_gtk_window_get_group (GtkWindow *window)
+gtk_window_get_group (GtkWindow *window)
{
if (window && window->group)
return window->group;
{
guint keyval;
guint modifiers;
- gboolean is_mnemonic;
+ guint is_mnemonic : 1;
};
+static void
+window_key_entry_destroy (gpointer data)
+{
+ g_slice_free (GtkWindowKeyEntry, data);
+}
+
static void
add_to_key_hash (GtkWindow *window,
guint keyval,
{
GtkKeyHash *key_hash = data;
- GtkWindowKeyEntry *entry = g_new (GtkWindowKeyEntry, 1);
+ GtkWindowKeyEntry *entry = g_slice_new (GtkWindowKeyEntry);
entry->keyval = keyval;
entry->modifiers = modifiers;
gtk_window_get_key_hash (GtkWindow *window)
{
GdkScreen *screen = gtk_window_check_screen (window);
- GtkKeyHash *key_hash = g_object_get_data (G_OBJECT (window), "gtk-window-key-hash");
+ GtkKeyHash *key_hash = g_object_get_qdata (G_OBJECT (window), quark_gtk_window_key_hash);
if (key_hash)
return key_hash;
key_hash = _gtk_key_hash_new (gdk_keymap_get_for_display (gdk_screen_get_display (screen)),
- (GDestroyNotify)g_free);
+ (GDestroyNotify)window_key_entry_destroy);
_gtk_window_keys_foreach (window, add_to_key_hash, key_hash);
- g_object_set_data (G_OBJECT (window), I_("gtk-window-key-hash"), key_hash);
+ g_object_set_qdata (G_OBJECT (window), quark_gtk_window_key_hash, key_hash);
return key_hash;
}
static void
gtk_window_free_key_hash (GtkWindow *window)
{
- GtkKeyHash *key_hash = g_object_get_data (G_OBJECT (window), "gtk-window-key-hash");
+ GtkKeyHash *key_hash = g_object_get_qdata (G_OBJECT (window), quark_gtk_window_key_hash);
if (key_hash)
{
_gtk_key_hash_free (key_hash);
- g_object_set_data (G_OBJECT (window), "gtk-window-key-hash", NULL);
+ g_object_set_qdata (G_OBJECT (window), quark_gtk_window_key_hash, NULL);
}
}
gtk_window_activate_key (GtkWindow *window,
GdkEventKey *event)
{
- GtkKeyHash *key_hash = g_object_get_data (G_OBJECT (window), "gtk-window-key-hash");
+ GtkKeyHash *key_hash = g_object_get_qdata (G_OBJECT (window), quark_gtk_window_key_hash);
GtkWindowKeyEntry *found_entry = NULL;
if (!key_hash)
{
gtk_window_keys_changed (window);
- key_hash = g_object_get_data (G_OBJECT (window), "gtk-window-key-hash");
+ key_hash = g_object_get_qdata (G_OBJECT (window), quark_gtk_window_key_hash);
}
if (key_hash)
if (found_entry)
{
+ gboolean enable_mnemonics;
+ gboolean enable_accels;
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (window)),
+ "gtk-enable-mnemonics", &enable_mnemonics,
+ "gtk-enable-accels", &enable_accels,
+ NULL);
+
if (found_entry->is_mnemonic)
- return gtk_window_mnemonic_activate (window, found_entry->keyval, found_entry->modifiers);
+ {
+ if (enable_mnemonics)
+ return gtk_window_mnemonic_activate (window, found_entry->keyval,
+ found_entry->modifiers);
+ }
else
- return gtk_accel_groups_activate (G_OBJECT (window), found_entry->keyval, found_entry->modifiers);
+ {
+ if (enable_accels)
+ return gtk_accel_groups_activate (G_OBJECT (window), found_entry->keyval,
+ found_entry->modifiers);
+ }
}
- else
- return FALSE;
+
+ return FALSE;
}
static void
* gtk_window_set_auto_startup_notification:
* @setting: %TRUE to automatically do startup notification
*
- * By default, after showing the first #GtkWindow for each #GdkScreen,
- * GTK+ calls gdk_screen_notify_startup_complete(). Call this
- * function to disable the automatic startup notification. You might
- * do this if your first window is a splash screen, and you want to
- * delay notification until after your real main window has been
- * shown, for example.
+ * By default, after showing the first #GtkWindow, GTK+ calls
+ * gdk_notify_startup_complete(). Call this function to disable
+ * the automatic startup notification. You might do this if your
+ * first window is a splash screen, and you want to delay notification
+ * until after your real main window has been shown, for example.
*
* In that example, you would disable startup notification
* temporarily, show your splash screen, then re-enable it so that