#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;
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.
*
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;
/**
* 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
/**
* 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
* 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.
+ * 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)
* 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_MAPPED (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.
*
* 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_get_size:
* @window: a #GtkWindow
- * @width: return location for width, or %NULL
- * @height: return location for height, or %NULL
+ * @width: (out): return location for width, or %NULL
+ * @height: (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
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);
/* 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
* 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)
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;
}
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
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
*
* 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)
*
* 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
**/
*
* 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)
}
/**
- * _gtk_windwo_set_is_toplevel:
+ * _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
_gtk_window_set_is_toplevel (GtkWindow *window,
gboolean is_toplevel)
{
- if (GTK_WIDGET_TOPLEVEL (window))
+ 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_TOPLEVEL (window))
+ if (is_toplevel == gtk_widget_is_toplevel (GTK_WIDGET (window)))
return;
if (is_toplevel)
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;
+}
+
+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;
+}
+
+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
projects / ~andy / gtk / blobdiff