#include "gtkkeyhash.h"
#include "gtkmain.h"
#include "gtkmnemonichash.h"
+#include "gtkmenubar.h"
#include "gtkiconfactory.h"
#include "gtkicontheme.h"
#include "gtkmarshalers.h"
/* Writeonly properties */
PROP_STARTUP_ID,
+ PROP_MNEMONICS_VISIBLE,
+
LAST_ARG
};
guint opacity_set : 1;
guint builder_visible : 1;
+ guint mnemonics_visible : 1;
+ guint mnemonics_visible_set : 1;
+
GdkWindowTypeHint type_hint;
gdouble opacity;
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 GQuark quark_gtk_buildable_accels = 0;
static GtkBuildableIface *parent_buildable_iface;
const GValue *value);
static void gtk_window_buildable_parser_finished (GtkBuildable *buildable,
GtkBuilder *builder);
+static gboolean gtk_window_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data);
+static void gtk_window_buildable_custom_finished (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer user_data);
G_DEFINE_TYPE_WITH_CODE (GtkWindow, gtk_window, GTK_TYPE_BIN,
/* Skip past the "_TIME" part */
timestr += 5;
-
+
+ errno = 0;
timestamp = strtoul (timestr, &end, 0);
if (end != timestr && errno == 0)
retval = timestamp;
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");
+ quark_gtk_buildable_accels = g_quark_from_static_string ("gtk-window-buildable-accels");
gobject_class->dispose = gtk_window_dispose;
gobject_class->finalize = gtk_window_finalize;
widget_class->focus_out_event = gtk_window_focus_out_event;
widget_class->client_event = gtk_window_client_event;
widget_class->focus = gtk_window_focus;
-
widget_class->expose_event = gtk_window_expose;
-
+
container_class->check_resize = gtk_window_check_resize;
klass->set_focus = gtk_window_real_set_focus;
P_("Unique identifier for the window to be used when restoring a session"),
NULL,
GTK_PARAM_READWRITE));
-
+
/**
* GtkWindow:startup-id:
*
* for more details.
*
* Since: 2.12
- */
+ */
g_object_class_install_property (gobject_class,
- PROP_ROLE,
+ PROP_STARTUP_ID,
g_param_spec_string ("startup-id",
P_("Startup ID"),
P_("Unique startup identifier for the window used by startup-notification"),
P_("Icon for this window"),
GDK_TYPE_PIXBUF,
GTK_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class,
+ PROP_MNEMONICS_VISIBLE,
+ g_param_spec_boolean ("mnemonics-visible",
+ P_("Mnemonics Visible"),
+ P_("Whether mnemonics are currently visible in this window"),
+ TRUE,
+ GTK_PARAM_READWRITE));
/**
* GtkWindow:icon-name:
GTK_PARAM_READWRITE));
/**
- * GtkWindow:accept-focus-hint:
+ * GtkWindow:accept-focus:
*
* Whether the window should receive the input focus.
*
GTK_PARAM_READWRITE));
/**
- * GtkWindow:focus-on-map-hint:
+ * GtkWindow:focus-on-map:
*
* Whether the window should receive the input focus when mapped.
*
P_("The transient parent of the dialog"),
GTK_TYPE_WINDOW,
GTK_PARAM_READWRITE| G_PARAM_CONSTRUCT));
+
/**
* GtkWindow:opacity:
*
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT);
+ /**
+ * GtkWindow::activate-focus:
+ * @window: the window which received the signal
+ *
+ * The ::activate-default signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted when the user activates the currently
+ * focused widget of @window.
+ */
window_signals[ACTIVATE_FOCUS] =
g_signal_new (I_("activate-focus"),
G_TYPE_FROM_CLASS (gobject_class),
G_TYPE_NONE,
0);
+ /**
+ * GtkWindow::activate-default:
+ * @window: the window which received the signal
+ *
+ * The ::activate-default signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted when the user activates the default widget
+ * of @window.
+ */
window_signals[ACTIVATE_DEFAULT] =
g_signal_new (I_("activate-default"),
G_TYPE_FROM_CLASS (gobject_class),
G_TYPE_NONE,
0);
+ /**
+ * GtkWindow::keys-changed:
+ * @window: the window which received the signal
+ *
+ * The ::keys-changed signal gets emitted when the set of accelerators
+ * or mnemonics that are associated with @window changes.
+ */
window_signals[KEYS_CHANGED] =
g_signal_new (I_("keys-changed"),
G_TYPE_FROM_CLASS (gobject_class),
priv->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
priv->opacity = 1.0;
priv->startup_id = NULL;
+ priv->mnemonics_visible = TRUE;
colormap = _gtk_widget_peek_colormap ();
if (colormap)
GParamSpec *pspec)
{
GtkWindow *window;
+ GtkWindowPrivate *priv;
window = GTK_WINDOW (object);
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
switch (prop_id)
{
case PROP_TYPE:
case PROP_OPACITY:
gtk_window_set_opacity (window, g_value_get_double (value));
break;
+ case PROP_MNEMONICS_VISIBLE:
+ gtk_window_set_mnemonics_visible (window, g_value_get_boolean (value));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
case PROP_OPACITY:
g_value_set_double (value, gtk_window_get_opacity (window));
break;
+ case PROP_MNEMONICS_VISIBLE:
+ g_value_set_boolean (value, priv->mnemonics_visible);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
parent_buildable_iface = g_type_interface_peek_parent (iface);
iface->set_buildable_property = gtk_window_buildable_set_buildable_property;
iface->parser_finished = gtk_window_buildable_parser_finished;
-
+ iface->custom_tag_start = gtk_window_buildable_custom_tag_start;
+ iface->custom_finished = gtk_window_buildable_custom_finished;
}
static void
GtkBuilder *builder)
{
GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (buildable);
+ GObject *object;
+ GSList *accels, *l;
if (priv->builder_visible)
gtk_widget_show (GTK_WIDGET (buildable));
- parent_buildable_iface->parser_finished (buildable, builder);
+ accels = g_object_get_qdata (G_OBJECT (buildable), quark_gtk_buildable_accels);
+ for (l = accels; l; l = l->next)
+ {
+ object = gtk_builder_get_object (builder, l->data);
+ if (!object)
+ {
+ g_warning ("Unknown accel group %s specified in window %s",
+ (const gchar*)l->data, gtk_buildable_get_name (buildable));
+ continue;
+ }
+ gtk_window_add_accel_group (GTK_WINDOW (buildable),
+ GTK_ACCEL_GROUP (object));
+ g_free (l->data);
+ }
+
+ g_object_set_qdata (G_OBJECT (buildable), quark_gtk_buildable_accels, NULL);
+
+ parent_buildable_iface->parser_finished (buildable, builder);
+}
+
+typedef struct {
+ GObject *object;
+ GSList *items;
+} GSListSubParserData;
+
+static void
+window_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **names,
+ const gchar **values,
+ gpointer user_data,
+ GError **error)
+{
+ guint i;
+ GSListSubParserData *data = (GSListSubParserData*)user_data;
+
+ if (strcmp (element_name, "group") == 0)
+ {
+ for (i = 0; names[i]; i++)
+ {
+ if (strcmp (names[i], "name") == 0)
+ data->items = g_slist_prepend (data->items, g_strdup (values[i]));
+ }
+ }
+ else if (strcmp (element_name, "accel-groups") == 0)
+ return;
+ else
+ g_warning ("Unsupported tag type for GtkWindow: %s\n",
+ element_name);
+
+}
+
+static const GMarkupParser window_parser =
+ {
+ window_start_element
+ };
+
+static gboolean
+gtk_window_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data)
+{
+ GSListSubParserData *parser_data;
+
+ if (parent_buildable_iface->custom_tag_start (buildable, builder, child,
+ tagname, parser, data))
+ return TRUE;
+
+ if (strcmp (tagname, "accel-groups") == 0)
+ {
+ parser_data = g_slice_new0 (GSListSubParserData);
+ parser_data->items = NULL;
+ parser_data->object = G_OBJECT (buildable);
+
+ *parser = window_parser;
+ *data = parser_data;
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+gtk_window_buildable_custom_finished (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer user_data)
+{
+ GSListSubParserData *data;
+
+ parent_buildable_iface->custom_finished (buildable, builder, child,
+ tagname, user_data);
+
+ if (strcmp (tagname, "accel-groups") != 0)
+ return;
+
+ data = (GSListSubParserData*)user_data;
+
+ g_object_set_qdata_full (G_OBJECT (buildable), quark_gtk_buildable_accels,
+ data->items, (GDestroyNotify) g_slist_free);
+
+ g_slice_free (GSListSubParserData, data);
}
/**
gtk_window_set_startup_id (GtkWindow *window,
const gchar *startup_id)
{
- GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
+ GtkWindowPrivate *priv;
g_return_if_fail (GTK_IS_WINDOW (window));
+
+ priv = GTK_WINDOW_GET_PRIVATE (window);
g_free (priv->startup_id);
priv->startup_id = g_strdup (startup_id);
-
+
if (GTK_WIDGET_REALIZED (window))
{
+ guint32 timestamp = extract_time_from_startup_id (priv->startup_id);
+
+#ifdef GDK_WINDOWING_X11
+ if (timestamp != GDK_CURRENT_TIME)
+ gdk_x11_window_set_user_time (GTK_WIDGET (window)->window, timestamp);
+#endif
+
/* Here we differentiate real and "fake" startup notification IDs,
* constructed on purpose just to pass interaction timestamp
- */
+ */
if (startup_id_is_fake (priv->startup_id))
- {
- guint32 timestamp = extract_time_from_startup_id (priv->startup_id);
-
- gtk_window_present_with_time (window, timestamp);
- }
+ gtk_window_present_with_time (window, timestamp);
else
{
gdk_window_set_startup_id (GTK_WIDGET (window)->window,
priv->startup_id);
/* If window is mapped, terminate the startup-notification too */
- if (GTK_WIDGET_MAPPED (window) && !disable_startup_notification)
+ if (gtk_widget_get_mapped (GTK_WIDGET (window)) &&
+ !disable_startup_notification)
gdk_notify_startup_complete_with_id (priv->startup_id);
}
}
/**
* gtk_window_set_focus:
* @window: a #GtkWindow
- * @focus: widget to be the new focus widget, or %NULL to unset
+ * @focus: (allow-none): widget to be the new focus widget, or %NULL to unset
* any focus widget for the toplevel window.
*
* If @focus is not the current focus widget, and is focusable, sets
if (focus)
{
g_return_if_fail (GTK_IS_WIDGET (focus));
- g_return_if_fail (GTK_WIDGET_CAN_FOCUS (focus));
+ g_return_if_fail (gtk_widget_get_can_focus (focus));
}
if (focus)
g_return_if_fail (GTK_IS_WINDOW (window));
if ((window->focus_widget != focus) ||
- (focus && !GTK_WIDGET_HAS_FOCUS (focus)))
+ (focus && !gtk_widget_has_focus (focus)))
g_signal_emit (window, window_signals[SET_FOCUS], 0, focus);
}
/**
* gtk_window_set_default:
* @window: a #GtkWindow
- * @default_widget: widget to be the default, or %NULL to unset the
+ * @default_widget: (allow-none): widget to be the default, or %NULL to unset the
* default widget for the toplevel.
*
* The default widget is the widget that's activated when the user
g_return_if_fail (GTK_IS_WINDOW (window));
if (default_widget)
- g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (default_widget));
+ g_return_if_fail (gtk_widget_get_can_default (default_widget));
if (window->default_widget != default_widget)
{
old_default_widget = window->default_widget;
if (window->focus_widget != window->default_widget ||
- !GTK_WIDGET_RECEIVES_DEFAULT (window->default_widget))
+ !gtk_widget_get_receives_default (window->default_widget))
GTK_WIDGET_UNSET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
gtk_widget_queue_draw (window->default_widget);
}
if (window->default_widget)
{
if (window->focus_widget == NULL ||
- !GTK_WIDGET_RECEIVES_DEFAULT (window->focus_widget))
+ !gtk_widget_get_receives_default (window->focus_widget))
GTK_WIDGET_SET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
gtk_widget_queue_draw (window->default_widget);
}
{
g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
- if (window->focus_widget && GTK_WIDGET_IS_SENSITIVE (window->focus_widget))
+ if (window->focus_widget && gtk_widget_is_sensitive (window->focus_widget))
return gtk_widget_activate (window->focus_widget);
return FALSE;
* Retrieves the current focused widget within the window.
* Note that this is the widget that would have the focus
* if the toplevel window focused; if the toplevel window
- * is not focused then <literal>GTK_WIDGET_HAS_FOCUS (widget)</literal> will
- * not be %TRUE for the widget.
- *
- * Return value: the currently focused widget, or %NULL if there is none.
+ * is not focused then <literal>gtk_widget_has_focus (widget)</literal> will
+ * not be %TRUE for the widget.
+ *
+ * Return value: (transfer none): the currently focused widget, or %NULL if there is none.
**/
GtkWidget *
gtk_window_get_focus (GtkWindow *window)
*
* Activates the default widget for the window, unless the current
* focused widget has been configured to receive the default action
- * (see #GTK_RECEIVES_DEFAULT in #GtkWidgetFlags), in which case the
+ * (see gtk_widget_set_receives_default()), in which case the
* focused widget is activated.
*
* Return value: %TRUE if a widget got activated.
{
g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
- if (window->default_widget && GTK_WIDGET_IS_SENSITIVE (window->default_widget) &&
- (!window->focus_widget || !GTK_WIDGET_RECEIVES_DEFAULT (window->focus_widget)))
+ if (window->default_widget && gtk_widget_is_sensitive (window->default_widget) &&
+ (!window->focus_widget || !gtk_widget_get_receives_default (window->focus_widget)))
return gtk_widget_activate (window->default_widget);
- else if (window->focus_widget && GTK_WIDGET_IS_SENSITIVE (window->focus_widget))
+ else if (window->focus_widget && gtk_widget_is_sensitive (window->focus_widget))
return gtk_widget_activate (window->focus_widget);
return FALSE;
gtk_window_set_modal (GtkWindow *window,
gboolean modal)
{
+ GtkWidget *widget;
+
g_return_if_fail (GTK_IS_WINDOW (window));
modal = modal != FALSE;
return;
window->modal = modal;
+ widget = GTK_WIDGET (window);
/* adjust desired modality state */
if (GTK_WIDGET_REALIZED (window))
{
- GtkWidget *widget = GTK_WIDGET (window);
-
if (window->modal)
gdk_window_set_modal_hint (widget->window, TRUE);
else
gdk_window_set_modal_hint (widget->window, FALSE);
}
- if (GTK_WIDGET_VISIBLE (window))
+ if (gtk_widget_get_visible (widget))
{
if (window->modal)
- gtk_grab_add (GTK_WIDGET (window));
+ gtk_grab_add (widget);
else
- gtk_grab_remove (GTK_WIDGET (window));
+ gtk_grab_remove (widget);
}
g_object_notify (G_OBJECT (window), "modal");
* callbacks that might destroy the widgets, you <emphasis>must</emphasis> call
* <literal>g_list_foreach (result, (GFunc)g_object_ref, NULL)</literal> first, and
* then unref all the widgets afterwards.
- *
- * Return value: list of toplevel widgets
+ *
+ * Return value: (element-type GtkWidget) (transfer container): list of toplevel widgets
**/
GList*
gtk_window_list_toplevels (void)
/**
* gtk_window_set_transient_for:
* @window: a #GtkWindow
- * @parent: parent window
+ * @parent: (allow-none): parent window
*
* Dialog windows should be set transient for the main application
* window they were spawned from. This allows <link
* Fetches the transient parent for this window. See
* gtk_window_set_transient_for().
*
- * Return value: the transient parent for this window, or %NULL
+ * Return value: (transfer none): the transient parent for this window, or %NULL
* if no transient parent has been set.
**/
GtkWindow *
GtkWindowPrivate *priv;
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (!GTK_WIDGET_VISIBLE (window));
+ g_return_if_fail (!gtk_widget_get_mapped (GTK_WIDGET (window)));
priv = GTK_WINDOW_GET_PRIVATE (window);
* Retrieves the list of icons set by gtk_window_set_icon_list().
* The list is copied, but the reference count on each
* member won't be incremented.
- *
- * Return value: copy of window's icon list
+ *
+ * Return value: (element-type GdkPixbuf) (transfer container): copy of window's icon list
**/
GList*
gtk_window_get_icon_list (GtkWindow *window)
/**
* gtk_window_set_icon:
* @window: a #GtkWindow
- * @icon: icon image, or %NULL
- *
+ * @icon: (allow-none): icon image, or %NULL
+ *
* Sets up the icon representing a #GtkWindow. This icon is used when
* the window is minimized (also known as iconified). Some window
* managers or desktop environments may also place it in the window
/**
* gtk_window_set_icon_name:
* @window: a #GtkWindow
- * @name: the name of the themed icon
+ * @name: (allow-none): the name of the themed icon
*
* Sets the icon for the window from a named themed icon. See
- * the docs for #GtkIconTheme for more details.
- *
+ * the docs for #GtkIconTheme for more details.
+ *
* Note that this has nothing to do with the WM_ICON_NAME
* property which is mentioned in the ICCCM.
*
info = ensure_icon_info (window);
+ if (g_strcmp0 (info->icon_name, name) == 0)
+ return;
+
tmp = info->icon_name;
info->icon_name = g_strdup (name);
g_free (tmp);
*
* Since: 2.6
*/
-G_CONST_RETURN gchar *
+const gchar *
gtk_window_get_icon_name (GtkWindow *window)
{
GtkWindowIconInfo *info;
* Gets the value set by gtk_window_set_icon() (or if you've
* called gtk_window_set_icon_list(), gets the first icon in
* the icon list).
- *
- * Return value: icon for window
+ *
+ * Return value: (transfer none): icon for window
**/
GdkPixbuf*
gtk_window_get_icon (GtkWindow *window)
* gtk_window_set_icon_from_file:
* @window: a #GtkWindow
* @filename: location of icon file
- * @err: location to store error, or %NULL.
+ * @err: (allow-none): location to store error, or %NULL.
*
* Sets the icon for @window.
* Warns on failure if @err is %NULL.
/**
* gtk_window_set_default_icon_name:
* @name: the name of the themed icon
- *
+ *
* Sets an icon to be used as fallback for windows that haven't
* had gtk_window_set_icon_list() called on them from a named
* themed icon, see gtk_window_set_icon_name().
g_list_free (toplevels);
}
+/**
+ * gtk_window_get_default_icon_name:
+ *
+ * Returns the fallback icon name for windows that has been set
+ * with gtk_window_set_default_icon_name(). The returned
+ * string is owned by GTK+ and should not be modified. It
+ * is only valid until the next call to
+ * gtk_window_set_default_icon_name().
+ *
+ * Returns: the fallback icon name for windows
+ *
+ * Since: 2.16
+ */
+const gchar *
+gtk_window_get_default_icon_name (void)
+{
+ return default_icon_name;
+}
+
/**
* gtk_window_set_default_icon_from_file:
* @filename: location of icon file
- * @err: location to store error, or %NULL.
+ * @err: (allow-none): location to store error, or %NULL.
*
* Sets an icon to be used as fallback for windows that haven't
* had gtk_window_set_icon_list() called on them from a file
/**
* gtk_window_get_default_size:
* @window: a #GtkWindow
- * @width: location to store the default width, or %NULL
- * @height: location to store the default height, or %NULL
+ * @width: (allow-none): location to store the default width, or %NULL
+ * @height: (allow-none): location to store the default height, or %NULL
*
* Gets the default size of the window. A value of -1 for the width or
* height indicates that a default size has not been explicitly set
/**
* gtk_window_get_size:
* @window: a #GtkWindow
- * @width: return location for width, or %NULL
- * @height: return location for height, or %NULL
+ * @width: (allow-none): (out): return location for width, or %NULL
+ * @height: (allow-none): (out): return location for height, or %NULL
*
* Obtains the current size of @window. If @window is not onscreen,
* it returns the size GTK+ will suggest to the <link
if (width == NULL && height == NULL)
return;
- if (GTK_WIDGET_MAPPED (window))
+ if (gtk_widget_get_mapped (GTK_WIDGET (window)))
{
gdk_drawable_get_size (GTK_WIDGET (window)->window,
&w, &h);
info = gtk_window_get_geometry_info (window, TRUE);
- if (GTK_WIDGET_MAPPED (window))
+ if (gtk_widget_get_mapped (widget))
{
/* we have now sent a request with this position
* with currently-active constraints, so toggle flag.
if (window->gravity == GDK_GRAVITY_STATIC)
{
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
{
/* This does a server round-trip, which is sort of wrong;
* but a server round-trip is inevitable for
gint x, y;
gint w, h;
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
{
if (window->frame)
gdk_window_get_frame_extents (window->frame, &frame_extents);
gtk_window_finalize (GObject *object)
{
GtkWindow *window = GTK_WINDOW (object);
+ GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
GtkMnemonicHash *mnemonic_hash;
g_free (window->title);
}
if (window->screen)
- {
- g_signal_handlers_disconnect_by_func (window->screen,
- gtk_window_on_composited_changed, window);
- }
-
+ g_signal_handlers_disconnect_by_func (window->screen,
+ gtk_window_on_composited_changed, window);
+
+ g_free (priv->startup_id);
+
G_OBJECT_CLASS (gtk_window_parent_class)->finalize (object);
}
GtkWindow *window = GTK_WINDOW (widget);
GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
GdkWindow *toplevel;
+ gboolean auto_mnemonics;
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
if (window->bin.child &&
- GTK_WIDGET_VISIBLE (window->bin.child) &&
- !GTK_WIDGET_MAPPED (window->bin.child))
+ gtk_widget_get_visible (window->bin.child) &&
+ !gtk_widget_get_mapped (window->bin.child))
gtk_widget_map (window->bin.child);
if (window->frame)
/* Make sure we have a "real" id */
if (!startup_id_is_fake (priv->startup_id))
gdk_notify_startup_complete_with_id (priv->startup_id);
-
+
+ g_free (priv->startup_id);
priv->startup_id = NULL;
}
else if (!sent_startup_notification)
gdk_notify_startup_complete ();
}
}
+
+ /* if auto-mnemonics is enabled and mnemonics visible is not already set
+ * (as in the case of popup menus), then hide mnemonics initially
+ */
+ g_object_get (gtk_widget_get_settings (widget), "gtk-auto-mnemonics",
+ &auto_mnemonics, NULL);
+ if (auto_mnemonics && !priv->mnemonics_visible_set)
+ gtk_window_set_mnemonics_visible (window, FALSE);
}
static gboolean
gtk_window_map_event (GtkWidget *widget,
GdkEventAny *event)
{
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
{
/* we should be be unmapped, but are getting a MapEvent, this may happen
* to toplevel XWindows if mapping was intercepted by a window manager
requisition->width = GTK_CONTAINER (window)->border_width * 2;
requisition->height = GTK_CONTAINER (window)->border_width * 2;
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
+ if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkRequisition child_requisition;
window = GTK_WINDOW (widget);
widget->allocation = *allocation;
- if (window->bin.child && GTK_WIDGET_VISIBLE (window->bin.child))
+ if (window->bin.child && gtk_widget_get_visible (window->bin.child))
{
child_allocation.x = GTK_CONTAINER (window)->border_width;
child_allocation.y = GTK_CONTAINER (window)->border_width;
* overriding the standard key handling for a toplevel window.
*
* Return value: %TRUE if a widget in the focus chain handled the event.
- **/
+ *
+ * Since: 2.4
+ */
gboolean
gtk_window_propagate_key_event (GtkWindow *window,
GdkEventKey *event)
{
GtkWidget *parent;
- if (GTK_WIDGET_IS_SENSITIVE (focus))
+ if (gtk_widget_is_sensitive (focus))
handled = gtk_widget_event (focus, (GdkEvent*) event);
parent = focus->parent;
* the window is visible before actually handling the
* event
*/
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
_gtk_window_set_has_toplevel_focus (window, TRUE);
_gtk_window_set_is_active (window, TRUE);
GdkEventFocus *event)
{
GtkWindow *window = GTK_WINDOW (widget);
+ gboolean auto_mnemonics;
_gtk_window_set_has_toplevel_focus (window, FALSE);
_gtk_window_set_is_active (window, FALSE);
+ /* set the mnemonic-visible property to false */
+ g_object_get (gtk_widget_get_settings (widget),
+ "gtk-auto-mnemonics", &auto_mnemonics, NULL);
+ if (auto_mnemonics)
+ gtk_window_set_mnemonics_visible (window, FALSE);
+
return FALSE;
}
while (embedded_windows)
{
- GdkNativeWindow xid = (GdkNativeWindow) embedded_windows->data;
+ GdkNativeWindow xid = GDK_GPOINTER_TO_NATIVE_WINDOW(embedded_windows->data);
gdk_event_send_client_message_for_display (gtk_widget_get_display (widget), send_event, xid);
embedded_windows = embedded_windows->next;
}
static void
gtk_window_check_resize (GtkContainer *container)
{
- GtkWindow *window = GTK_WINDOW (container);
-
- if (GTK_WIDGET_VISIBLE (container))
- gtk_window_move_resize (window);
+ if (gtk_widget_get_visible (GTK_WIDGET (container)))
+ gtk_window_move_resize (GTK_WINDOW (container));
}
static gboolean
{
g_object_ref (old_focus);
g_object_freeze_notify (G_OBJECT (old_focus));
- old_focus_had_default = GTK_WIDGET_HAS_DEFAULT (old_focus);
+ old_focus_had_default = gtk_widget_has_default (old_focus);
}
if (focus)
{
g_object_ref (focus);
g_object_freeze_notify (G_OBJECT (focus));
- focus_had_default = GTK_WIDGET_HAS_DEFAULT (focus);
+ focus_had_default = gtk_widget_has_default (focus);
}
if (window->default_widget)
- had_default = GTK_WIDGET_HAS_DEFAULT (window->default_widget);
+ had_default = gtk_widget_has_default (window->default_widget);
if (window->focus_widget)
{
- if (GTK_WIDGET_RECEIVES_DEFAULT (window->focus_widget) &&
+ if (gtk_widget_get_receives_default (window->focus_widget) &&
(window->focus_widget != window->default_widget))
{
GTK_WIDGET_UNSET_FLAGS (window->focus_widget, GTK_HAS_DEFAULT);
{
window->focus_widget = focus;
- if (GTK_WIDGET_RECEIVES_DEFAULT (window->focus_widget) &&
+ if (gtk_widget_get_receives_default (window->focus_widget) &&
(window->focus_widget != window->default_widget))
{
- if (GTK_WIDGET_CAN_DEFAULT (window->focus_widget))
+ if (gtk_widget_get_can_default (window->focus_widget))
GTK_WIDGET_SET_FLAGS (window->focus_widget, GTK_HAS_DEFAULT);
if (window->default_widget)
* is harmless.
*/
if (window->default_widget &&
- (had_default != GTK_WIDGET_HAS_DEFAULT (window->default_widget)))
+ (had_default != gtk_widget_has_default (window->default_widget)))
gtk_widget_queue_draw (window->default_widget);
if (old_focus)
{
- if (old_focus_had_default != GTK_WIDGET_HAS_DEFAULT (old_focus))
+ if (old_focus_had_default != gtk_widget_has_default (old_focus))
gtk_widget_queue_draw (old_focus);
g_object_thaw_notify (G_OBJECT (old_focus));
}
if (focus)
{
- if (focus_had_default != GTK_WIDGET_HAS_DEFAULT (focus))
+ if (focus_had_default != gtk_widget_has_default (focus))
gtk_widget_queue_draw (focus);
g_object_thaw_notify (G_OBJECT (focus));
if (info->resize_height > 0)
*height = info->resize_height;
}
+
+ /* Don't ever request zero width or height, its not supported by
+ gdk. The size allocation code will round it to 1 anyway but if
+ we do it then the value returned from this function will is
+ not comparable to the size allocation read from the GtkWindow. */
+ *width = MAX (*width, 1);
+ *height = MAX (*height, 1);
}
static GtkWindowPosition
get_effective_position (GtkWindow *window)
{
GtkWindowPosition pos = window->position;
+
if (pos == GTK_WIN_POS_CENTER_ON_PARENT &&
(window->transient_parent == NULL ||
- !GTK_WIDGET_MAPPED (window->transient_parent)))
+ !gtk_widget_get_mapped (GTK_WIDGET (window->transient_parent))))
pos = GTK_WIN_POS_NONE;
return pos;
const GdkRectangle *rect)
{
#ifdef DEBUGGING_OUTPUT
- g_print ("%s: %+d%+d %dx%d: %+d%+d: %dx%d", __FUNCTION__, rect->x, rect->y, rect->width, rect->height, *x, *y, w, h);
+ g_print ("%s: %+d%+d %dx%d: %+d%+d: %dx%d", G_STRFUNC, rect->x, rect->y, rect->width, rect->height, *x, *y, w, h);
#endif
/* If it is too large, center it. If it fits on the monitor but is
GdkRectangle monitor;
gint ox, oy;
- g_assert (GTK_WIDGET_MAPPED (parent_widget)); /* established earlier */
+ g_assert (gtk_widget_get_mapped (parent_widget)); /* established earlier */
if (parent_widget->window != NULL)
monitor_num = gdk_screen_get_monitor_at_window (screen,
gtk_window_expose (GtkWidget *widget,
GdkEventExpose *event)
{
- if (!GTK_WIDGET_APP_PAINTABLE (widget))
+ if (!gtk_widget_get_app_paintable (widget))
gtk_window_paint (widget, &event->area);
if (GTK_WIDGET_CLASS (gtk_window_parent_class)->expose_event)
widget = GTK_WIDGET (window);
- if (GTK_WIDGET_VISIBLE (window))
+ if (gtk_widget_get_visible (widget))
{
g_assert (widget->window != NULL);
*
* Gets the value set by gtk_window_set_gravity().
*
- * Return value: window gravity
+ * Return value: (transfer none): window gravity
**/
GdkGravity
gtk_window_get_gravity (GtkWindow *window)
GdkWindow *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (GTK_WIDGET_VISIBLE (window));
-
widget = GTK_WIDGET (window);
+ g_return_if_fail (gtk_widget_get_visible (widget));
if (window->frame)
toplevel = window->frame;
/**
* gtk_window_get_frame_dimensions:
* @window: a #GtkWindow
- * @left: location to store the width of the frame at the left, or %NULL
- * @top: location to store the height of the frame at the top, or %NULL
- * @right: location to store the width of the frame at the returns, or %NULL
- * @bottom: location to store the height of the frame at the bottom, or %NULL
+ * @left: (allow-none): location to store the width of the frame at the left, or %NULL
+ * @top: (allow-none): location to store the height of the frame at the top, or %NULL
+ * @right: (allow-none): location to store the width of the frame at the returns, or %NULL
+ * @bottom: (allow-none): location to store the height of the frame at the bottom, or %NULL
*
* (Note: this is a special-purpose function intended for the
* framebuffer port; see gtk_window_set_has_frame(). It will not
GdkWindow *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (GTK_WIDGET_VISIBLE (window));
-
widget = GTK_WIDGET (window);
+ g_return_if_fail (gtk_widget_get_visible (widget));
if (window->frame)
toplevel = window->frame;
widget = GTK_WIDGET (window);
previous_screen = window->screen;
- was_mapped = GTK_WIDGET_MAPPED (widget);
+ was_mapped = gtk_widget_get_mapped (widget);
if (was_mapped)
gtk_widget_unmap (widget);
*
* Returns the #GdkScreen associated with @window.
*
- * Return value: a #GdkScreen.
+ * Return value: (transfer none): a #GdkScreen.
*
* Since: 2.2
*/
*
* Returns a list of the #GtkWindows that belong to @window_group.
*
- * Returns: A newly-allocated list of windows inside the group.
+ * Returns: (element-type GtkWidget) (transfer container): A newly-allocated list of
+ * windows inside the group.
*
* Since: 2.14
**/
/**
* gtk_window_get_group:
- * @window: a #GtkWindow, or %NULL
+ * @window: (allow-none): 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.
+ * window group.
*
- * Returns: the #GtkWindowGroup for a window or the default group
+ * Returns: (transfer none): the #GtkWindowGroup for a window or the default group
*
* Since: 2.10
*/
* overriding the standard key handling for a toplevel window.
*
* Return value: %TRUE if a mnemonic or accelerator was found and activated.
- **/
+ *
+ * Since: 2.4
+ */
gboolean
gtk_window_activate_key (GtkWindow *window,
GdkEventKey *event)
{
GtkKeyHash *key_hash;
GtkWindowKeyEntry *found_entry = NULL;
+ gboolean enable_mnemonics;
+ gboolean enable_accels;
g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if (key_hash)
{
+ GSList *tmp_list;
GSList *entries = _gtk_key_hash_lookup (key_hash,
event->hardware_keycode,
event->state,
gtk_accelerator_get_default_mod_mask (),
event->group);
- GSList *tmp_list;
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (window)),
+ "gtk-enable-mnemonics", &enable_mnemonics,
+ "gtk-enable-accels", &enable_accels,
+ NULL);
for (tmp_list = entries; tmp_list; tmp_list = tmp_list->next)
{
GtkWindowKeyEntry *entry = tmp_list->data;
if (entry->is_mnemonic)
- {
- found_entry = entry;
- break;
- }
+ {
+ if (enable_mnemonics)
+ {
+ found_entry = entry;
+ break;
+ }
+ }
+ else
+ {
+ if (enable_accels && !found_entry)
+ {
+ found_entry = entry;
+ }
+ }
}
-
- if (!found_entry && entries)
- found_entry = entries->data;
g_slist_free (entries);
}
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)
{
if (enable_mnemonics)
{
if (window->focus_widget &&
window->focus_widget != widget &&
- !GTK_WIDGET_HAS_FOCUS (window->focus_widget))
+ !gtk_widget_has_focus (window->focus_widget))
do_focus_change (window->focus_widget, TRUE);
}
else
{
if (window->focus_widget &&
window->focus_widget != widget &&
- GTK_WIDGET_HAS_FOCUS (window->focus_widget))
+ gtk_widget_has_focus (window->focus_widget))
do_focus_change (window->focus_widget, FALSE);
}
}
}
}
+/**
+ * _gtk_window_set_is_toplevel:
+ * @window: a #GtkWindow
+ * @is_toplevel: %TRUE if the window is still a real toplevel (nominally a
+ * parent of the root window); %FALSE if it is not (for example, for an
+ * 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.
+ */
+void
+_gtk_window_set_is_toplevel (GtkWindow *window,
+ gboolean is_toplevel)
+{
+ if (gtk_widget_is_toplevel (GTK_WIDGET (window)))
+ g_assert (g_slist_find (toplevel_list, window) != NULL);
+ else
+ g_assert (g_slist_find (toplevel_list, window) == NULL);
+
+ if (is_toplevel == gtk_widget_is_toplevel (GTK_WIDGET (window)))
+ return;
+
+ if (is_toplevel)
+ {
+ GTK_WIDGET_SET_FLAGS (window, GTK_TOPLEVEL);
+ toplevel_list = g_slist_prepend (toplevel_list, window);
+ }
+ else
+ {
+ GTK_WIDGET_UNSET_FLAGS (window, GTK_TOPLEVEL);
+ toplevel_list = g_slist_remove (toplevel_list, window);
+ }
+}
+
/**
* _gtk_window_set_has_toplevel_focus:
* @window: a #GtkWindow
disable_startup_notification = !setting;
}
+/**
+ * gtk_window_get_window_type:
+ * @window: a #GtkWindow
+ *
+ * Gets the type of the window. See #GtkWindowType.
+ *
+ * Return value: the type of the window
+ *
+ * Since: 2.20
+ **/
+GtkWindowType
+gtk_window_get_window_type (GtkWindow *window)
+{
+ g_return_val_if_fail (GTK_IS_WINDOW (window), GTK_WINDOW_TOPLEVEL);
+
+ return window->type;
+}
+
+/* gtk_window_get_mnemonics_visible:
+ * @window: a #GtkWindow
+ *
+ * Gets the value of the #GtkWindow:mnemonics-visible property.
+ *
+ * Returns: %TRUE if mnemonics are supposed to be visible
+ * in this window.
+ *
+ * Since: 2.20
+ */
+gboolean
+gtk_window_get_mnemonics_visible (GtkWindow *window)
+{
+ GtkWindowPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
+
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ return priv->mnemonics_visible;
+}
+
+/**
+ * gtk_window_set_mnemonics_visible:
+ * @window: a #GtkWindow
+ * @setting: the new value
+ *
+ * Sets the #GtkWindow:mnemonics-visible property.
+ *
+ * Since: 2.20
+ */
+void
+gtk_window_set_mnemonics_visible (GtkWindow *window,
+ gboolean setting)
+{
+ GtkWindowPrivate *priv;
+
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ setting = setting != FALSE;
+
+ if (priv->mnemonics_visible != setting)
+ {
+ priv->mnemonics_visible = setting;
+ g_object_notify (G_OBJECT (window), "mnemonics-visible");
+ }
+
+ priv->mnemonics_visible_set = TRUE;
+}
+
#if defined (G_OS_WIN32) && !defined (_WIN64)
#undef gtk_window_set_icon_from_file