#include "gtkmarshalers.h"
#include "gtkplug.h"
#include "gtkbuildable.h"
-#include "gtkalias.h"
+#include "gtksizerequest.h"
#ifdef GDK_WINDOWING_X11
#include "x11/gdkx.h"
#endif
+/**
+ * SECTION:gtkwindow
+ * @title: GtkWindow
+ * @short_description: Toplevel which can contain other widgets
+ *
+ * <refsect2 id="GtkWindow-BUILDER-UI">
+ * <title>GtkWindow as GtkBuildable</title>
+ * <para>
+ * The GtkWindow implementation of the GtkBuildable interface supports a
+ * custom <tag class="starttag">accel-groups</tag> element, which supports
+ * any number of <tag class="starttag">group</tag> elements representing the
+ * #GtkAccelGroup objects you want to add to your window (synonymous with
+ * gtk_window_add_accel_group().
+ * </para>
+ * <example>
+ * <title>A UI definition fragment with accel groups</title>
+ * <programlisting><![CDATA[
+ * <object class="GtkWindow">
+ * <accel-groups>
+ * <group name="accelgroup1"/>
+ * </accel-groups>
+ * </object>
+ * <!-- -->
+ * ...
+ * <!-- -->
+ * <object class="GtkAccelGroup" id="accelgroup1"/>
+ * ]]></programlisting>
+ * </example>
+ * </refsect2>
+ */
enum {
SET_FOCUS,
FRAME_EVENT,
};
#define GTK_WINDOW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_WINDOW, GtkWindowPrivate))
+#define GTK_WINDOW_GROUP_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_WINDOW_GROUP, GtkWindowGroupPrivate))
typedef struct _GtkWindowPrivate GtkWindowPrivate;
gchar *startup_id;
};
+typedef struct _GtkDeviceGrabInfo GtkDeviceGrabInfo;
+typedef struct _GtkWindowGroupPrivate GtkWindowGroupPrivate;
+
+struct _GtkDeviceGrabInfo
+{
+ GtkWidget *widget;
+ GdkDevice *device;
+ guint block_others : 1;
+};
+
+struct _GtkWindowGroupPrivate
+{
+ GSList *device_grabs;
+};
+
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_unmap (GtkWidget *widget);
static void gtk_window_realize (GtkWidget *widget);
static void gtk_window_unrealize (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_event (GtkWidget *widget,
gpointer user_data);
+static void gtk_window_size_request_init (GtkSizeRequestIface *iface);
+static void gtk_window_get_width (GtkSizeRequest *widget,
+ gint *minimum_size,
+ gint *natural_size);
+static void gtk_window_get_height (GtkSizeRequest *widget,
+ gint *minimum_size,
+ gint *natural_size);
+
G_DEFINE_TYPE_WITH_CODE (GtkWindow, gtk_window, GTK_TYPE_BIN,
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
- gtk_window_buildable_interface_init))
+ gtk_window_buildable_interface_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_SIZE_REQUEST,
+ gtk_window_size_request_init))
static void
add_tab_bindings (GtkBindingSet *binding_set,
widget_class->unmap = gtk_window_unmap;
widget_class->realize = gtk_window_realize;
widget_class->unrealize = gtk_window_unrealize;
- widget_class->size_request = gtk_window_size_request;
widget_class->size_allocate = gtk_window_size_allocate;
widget_class->configure_event = gtk_window_configure_event;
widget_class->key_press_event = gtk_window_key_press_event;
NULL,
GTK_PARAM_WRITABLE));
- g_object_class_install_property (gobject_class,
- PROP_ALLOW_SHRINK,
- g_param_spec_boolean ("allow-shrink",
- P_("Allow Shrink"),
- /* xgettext:no-c-format */
- P_("If TRUE, the window has no mimimum size. Setting this to TRUE is 99% of the time a bad idea"),
- FALSE,
- GTK_PARAM_READWRITE));
-
- g_object_class_install_property (gobject_class,
- PROP_ALLOW_GROW,
- g_param_spec_boolean ("allow-grow",
- P_("Allow Grow"),
- P_("If TRUE, users can expand the window beyond its minimum size"),
- TRUE,
- GTK_PARAM_READWRITE));
-
g_object_class_install_property (gobject_class,
PROP_RESIZABLE,
g_param_spec_boolean ("resizable",
* GtkWindow::activate-focus:
* @window: the window which received the signal
*
- * The ::activate-default signal is a
+ * The ::activate-focus signal is a
* <link linkend="keybinding-signals">keybinding signal</link>
* which gets emitted when the user activates the currently
* focused widget of @window.
GdkColormap *colormap;
GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
- GTK_WIDGET_UNSET_FLAGS (window, GTK_NO_WINDOW);
- GTK_WIDGET_SET_FLAGS (window, GTK_TOPLEVEL);
+ gtk_widget_set_has_window (GTK_WIDGET (window), TRUE);
+ _gtk_widget_set_is_toplevel (GTK_WIDGET (window), TRUE);
GTK_PRIVATE_SET_FLAG (window, GTK_ANCHORED);
window->focus_widget = NULL;
window->default_widget = NULL;
window->configure_request_count = 0;
- window->allow_shrink = FALSE;
- window->allow_grow = TRUE;
+ window->resizable = TRUE;
window->configure_notify_received = FALSE;
window->position = GTK_WIN_POS_NONE;
window->need_default_size = TRUE;
case PROP_STARTUP_ID:
gtk_window_set_startup_id (window, g_value_get_string (value));
break;
- case PROP_ALLOW_SHRINK:
- window->allow_shrink = g_value_get_boolean (value);
- gtk_widget_queue_resize (GTK_WIDGET (window));
- break;
- case PROP_ALLOW_GROW:
- window->allow_grow = g_value_get_boolean (value);
- gtk_widget_queue_resize (GTK_WIDGET (window));
- g_object_notify (G_OBJECT (window), "resizable");
- break;
case PROP_RESIZABLE:
- window->allow_grow = g_value_get_boolean (value);
+ window->resizable = g_value_get_boolean (value);
gtk_widget_queue_resize (GTK_WIDGET (window));
- g_object_notify (G_OBJECT (window), "allow-grow");
break;
case PROP_MODAL:
gtk_window_set_modal (window, g_value_get_boolean (value));
case PROP_TITLE:
g_value_set_string (value, window->title);
break;
- case PROP_ALLOW_SHRINK:
- g_value_set_boolean (value, window->allow_shrink);
- break;
- case PROP_ALLOW_GROW:
- g_value_set_boolean (value, window->allow_grow);
- break;
case PROP_RESIZABLE:
- g_value_set_boolean (value, window->allow_grow);
+ g_value_set_boolean (value, window->resizable);
break;
case PROP_MODAL:
g_value_set_boolean (value, window->modal);
g_free (window->title);
window->title = new_title;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
{
gdk_window_set_title (GTK_WIDGET (window)->window, window->title);
g_free (window->wmclass_class);
window->wmclass_class = g_strdup (wmclass_class);
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
g_warning ("gtk_window_set_wmclass: shouldn't set wmclass after window is realized!\n");
}
g_free (window->wm_role);
window->wm_role = new_role;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_role (GTK_WIDGET (window)->window, window->wm_role);
g_object_notify (G_OBJECT (window), "role");
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))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
{
guint32 timestamp = extract_time_from_startup_id (priv->startup_id);
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);
}
}
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);
}
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_UNSET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
+ !gtk_widget_get_receives_default (window->default_widget))
+ _gtk_widget_set_has_default (window->default_widget, FALSE);
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_SET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
+ !gtk_widget_get_receives_default (window->focus_widget))
+ _gtk_widget_set_has_default (window->default_widget, TRUE);
gtk_widget_queue_draw (window->default_widget);
}
return window->default_widget;
}
-static void
-gtk_window_set_policy_internal (GtkWindow *window,
- gboolean allow_shrink,
- gboolean allow_grow,
- gboolean auto_shrink)
-{
- window->allow_shrink = (allow_shrink != FALSE);
- window->allow_grow = (allow_grow != FALSE);
-
- g_object_freeze_notify (G_OBJECT (window));
- g_object_notify (G_OBJECT (window), "allow-shrink");
- g_object_notify (G_OBJECT (window), "allow-grow");
- g_object_notify (G_OBJECT (window), "resizable");
- g_object_thaw_notify (G_OBJECT (window));
-
- gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
-}
-
-void
-gtk_window_set_policy (GtkWindow *window,
- gboolean allow_shrink,
- gboolean allow_grow,
- gboolean auto_shrink)
-{
- g_return_if_fail (GTK_IS_WINDOW (window));
-
- gtk_window_set_policy_internal (window, allow_shrink, allow_grow, auto_shrink);
-}
-
static gboolean
handle_keys_changed (gpointer data)
{
{
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
+ * 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.
*
* 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))
+ if (gtk_widget_get_realized (widget))
{
- 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");
gtk_window_transient_parent_realized (GtkWidget *parent,
GtkWidget *window)
{
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_transient_for (window->window, parent->window);
}
gtk_window_transient_parent_unrealized (GtkWidget *parent,
GtkWidget *window)
{
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_property_delete (window->window,
gdk_atom_intern_static_string ("WM_TRANSIENT_FOR"));
}
/**
* gtk_window_set_transient_for:
* @window: a #GtkWindow
- * @parent: (allow-none): parent window
+ * @parent: (allow-none): parent window, or %NULL
*
* Dialog windows should be set transient for the main application
* window they were spawned from. This allows <link
* functions in GTK+ will sometimes call
* gtk_window_set_transient_for() on your behalf.
*
- * On Windows, this function puts the child window on top of the parent,
+ * Passing %NULL for @parent unsets the current transient window.
+ *
+ * On Windows, this function puts the child window on top of the parent,
* much as the window manager would have done on X.
- *
- **/
-void
-gtk_window_set_transient_for (GtkWindow *window,
+ */
+void
+gtk_window_set_transient_for (GtkWindow *window,
GtkWindow *parent)
{
- GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
+ GtkWindowPrivate *priv;
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
g_return_if_fail (window != parent);
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
if (window->transient_parent)
{
- if (GTK_WIDGET_REALIZED (window) &&
- GTK_WIDGET_REALIZED (window->transient_parent) &&
- (!parent || !GTK_WIDGET_REALIZED (parent)))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)) &&
+ gtk_widget_get_realized (GTK_WIDGET (window->transient_parent)) &&
+ (!parent || !gtk_widget_get_realized (GTK_WIDGET (parent))))
gtk_window_transient_parent_unrealized (GTK_WIDGET (window->transient_parent),
GTK_WIDGET (window));
if (window->destroy_with_parent)
connect_parent_destroyed (window);
- if (GTK_WIDGET_REALIZED (window) &&
- GTK_WIDGET_REALIZED (parent))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)) &&
+ gtk_widget_get_realized (GTK_WIDGET (parent)))
gtk_window_transient_parent_realized (GTK_WIDGET (parent),
GTK_WIDGET (window));
priv->opacity_set = TRUE;
priv->opacity = opacity;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_opacity (GTK_WIDGET (window)->window, priv->opacity);
}
GtkWindowPrivate *priv;
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (!GTK_WIDGET_MAPPED (window));
+ g_return_if_fail (!gtk_widget_get_mapped (GTK_WIDGET (window)));
priv = GTK_WINDOW_GET_PRIVATE (window);
if (priv->skips_taskbar != setting)
{
priv->skips_taskbar = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_skip_taskbar_hint (GTK_WIDGET (window)->window,
priv->skips_taskbar);
g_object_notify (G_OBJECT (window), "skip-taskbar-hint");
if (priv->skips_pager != setting)
{
priv->skips_pager = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_skip_pager_hint (GTK_WIDGET (window)->window,
priv->skips_pager);
g_object_notify (G_OBJECT (window), "skip-pager-hint");
if (priv->urgent != setting)
{
priv->urgent = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_urgency_hint (GTK_WIDGET (window)->window,
priv->urgent);
g_object_notify (G_OBJECT (window), "urgency-hint");
if (priv->accept_focus != setting)
{
priv->accept_focus = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_accept_focus (GTK_WIDGET (window)->window,
priv->accept_focus);
g_object_notify (G_OBJECT (window), "accept-focus");
if (priv->focus_on_map != setting)
{
priv->focus_on_map = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_focus_on_map (GTK_WIDGET (window)->window,
priv->focus_on_map);
g_object_notify (G_OBJECT (window), "focus-on-map");
/**
* gtk_window_set_geometry_hints:
* @window: a #GtkWindow
- * @geometry_widget: widget the geometry hints will be applied to
- * @geometry: struct containing geometry information
+ * @geometry_widget: (allow-none): widget the geometry hints will be applied to or %NULL
+ * @geometry: (allow-none): struct containing geometry information or %NULL
* @geom_mask: mask indicating which struct fields should be paid attention to
*
* This function sets up hints about how a window can be resized by
/**
* gtk_window_set_icon_list:
* @window: a #GtkWindow
- * @list: list of #GdkPixbuf
+ * @list: (element-type GdkPixbuf) (transfer container): list of #GdkPixbuf
*
* Sets up the icon representing a #GtkWindow. The icon is used when
* the window is minimized (also known as iconified). Some window
gtk_window_unrealize_icon (window);
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gtk_window_realize_icon (window);
/* We could try to update our transient children, but I don't think
gtk_window_unrealize_icon (window);
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gtk_window_realize_icon (window);
}
*
* Since: 2.6
*/
-G_CONST_RETURN gchar *
+const gchar *
gtk_window_get_icon_name (GtkWindow *window)
{
GtkWindowIconInfo *info;
* 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_list:
- * @list: a list of #GdkPixbuf
+ * @list: (element-type GdkPixbuf) (transfer container): a list of #GdkPixbuf
*
* Sets an icon list to be used as fallback for windows that haven't
* had gtk_window_set_icon_list() called on them to set up a
if (info && info->using_default_icon)
{
gtk_window_unrealize_icon (w);
- if (GTK_WIDGET_REALIZED (w))
+ if (gtk_widget_get_realized (GTK_WIDGET (w)))
gtk_window_realize_icon (w);
}
if (info && info->using_default_icon && info->using_themed_icon)
{
gtk_window_unrealize_icon (w);
- if (GTK_WIDGET_REALIZED (w))
+ if (gtk_widget_get_realized (GTK_WIDGET (w)))
gtk_window_realize_icon (w);
}
/**
* 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
* but the pixbufs in the list have not had their reference count
* incremented.
*
- * Return value: copy of default icon list
+ * Return value: (element-type GdkPixbuf) (transfer container): copy of default icon list
**/
GList*
gtk_window_get_default_icon_list (void)
/**
* 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: (out) (allow-none): location to store the default width, or %NULL
+ * @height: (out) (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: (out): return location for width, or %NULL
- * @height: (out): return location for height, or %NULL
+ * @width: (out) (allow-none): return location for width, or %NULL
+ * @height: (out) (allow-none): 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.
/**
* gtk_window_get_position:
* @window: a #GtkWindow
- * @root_x: return location for X coordinate of gravity-determined reference point
- * @root_y: return location for Y coordinate of gravity-determined reference point
+ * @root_x: (out): return location for X coordinate of gravity-determined reference point
+ * @root_y: (out): return location for Y coordinate of gravity-determined reference point
*
* This function returns the position you need to pass to
* gtk_window_move() to keep @window in its current position. This
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);
gboolean need_resize;
GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
-
- need_resize = container->need_resize || !GTK_WIDGET_REALIZED (widget);
- container->need_resize = FALSE;
+
+ need_resize = _gtk_container_get_need_resize (container) || !gtk_widget_get_realized (widget);
+ _gtk_container_set_need_resize (container, FALSE);
if (need_resize)
{
/* Then we guarantee we have a realize */
was_realized = FALSE;
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
{
gtk_widget_realize (widget);
was_realized = TRUE;
static void
gtk_window_map (GtkWidget *widget)
{
+ GtkWidget *child;
GtkWindow *window = GTK_WINDOW (widget);
GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
GdkWindow *toplevel;
gboolean auto_mnemonics;
- GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+ gtk_widget_set_mapped (widget, TRUE);
- if (window->bin.child &&
- GTK_WIDGET_VISIBLE (window->bin.child) &&
- !GTK_WIDGET_MAPPED (window->bin.child))
- gtk_widget_map (window->bin.child);
+ child = gtk_bin_get_child (&(window->bin));
+ if (child &&
+ gtk_widget_get_visible (child) &&
+ !gtk_widget_get_mapped (child))
+ gtk_widget_map (child);
if (window->frame)
toplevel = window->frame;
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
GtkWindowGeometryInfo *info;
GdkWindowState state;
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+ gtk_widget_set_mapped (widget, FALSE);
if (window->frame)
gdk_window_withdraw (window->frame);
else
_gtk_container_queue_resize (GTK_CONTAINER (widget));
- g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
+ g_return_if_fail (!gtk_widget_get_realized (widget));
}
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ gtk_widget_set_realized (widget, TRUE);
switch (window->type)
{
gtk_window_paint (widget, NULL);
if (window->transient_parent &&
- GTK_WIDGET_REALIZED (window->transient_parent))
+ gtk_widget_get_realized (GTK_WIDGET (window->transient_parent)))
gdk_window_set_transient_for (widget->window,
GTK_WIDGET (window->transient_parent)->window);
GTK_WIDGET_CLASS (gtk_window_parent_class)->unrealize (widget);
}
-static void
-gtk_window_size_request (GtkWidget *widget,
- GtkRequisition *requisition)
-{
- GtkWindow *window;
- GtkBin *bin;
-
- window = GTK_WINDOW (widget);
- bin = GTK_BIN (window);
-
- requisition->width = GTK_CONTAINER (window)->border_width * 2;
- requisition->height = GTK_CONTAINER (window)->border_width * 2;
-
- if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
- {
- GtkRequisition child_requisition;
-
- gtk_widget_size_request (bin->child, &child_requisition);
-
- requisition->width += child_requisition.width;
- requisition->height += child_requisition.height;
- }
-}
-
static void
gtk_window_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkWindow *window;
GtkAllocation child_allocation;
+ GtkWidget *child;
+ guint border_width;
window = GTK_WINDOW (widget);
widget->allocation = *allocation;
- if (window->bin.child && GTK_WIDGET_VISIBLE (window->bin.child))
+ child = gtk_bin_get_child (&(window->bin));
+ if (child && gtk_widget_get_visible (child))
{
- child_allocation.x = GTK_CONTAINER (window)->border_width;
- child_allocation.y = GTK_CONTAINER (window)->border_width;
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (window));
+ child_allocation.x = border_width;
+ child_allocation.y = border_width;
child_allocation.width =
MAX (1, (gint)allocation->width - child_allocation.x * 2);
child_allocation.height =
MAX (1, (gint)allocation->height - child_allocation.y * 2);
- gtk_widget_size_allocate (window->bin.child, &child_allocation);
+ gtk_widget_size_allocate (child, &child_allocation);
}
- if (GTK_WIDGET_REALIZED (widget) && window->frame)
+ if (gtk_widget_get_realized (widget) && window->frame)
{
gdk_window_resize (window->frame,
allocation->width + window->frame_left + window->frame_right,
{
GtkWidget *parent;
- if (GTK_WIDGET_IS_SENSITIVE (focus))
+ if (gtk_widget_is_sensitive (focus))
handled = gtk_widget_event (focus, (GdkEvent*) event);
parent = focus->parent;
{
gtk_widget_child_focus (GTK_WIDGET (window), dir);
- if (!GTK_CONTAINER (window)->focus_child)
+ if (!gtk_container_get_focus_child (GTK_CONTAINER (window)))
gtk_window_set_focus (window, NULL);
}
do_focus_change (GtkWidget *widget,
gboolean in)
{
- GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
-
+ GdkDeviceManager *device_manager;
+ GList *devices, *d;
+
g_object_ref (widget);
-
- if (in)
- GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
- else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
-
- fevent->focus_change.type = GDK_FOCUS_CHANGE;
- fevent->focus_change.window = widget->window;
- if (widget->window)
- g_object_ref (widget->window);
- fevent->focus_change.in = in;
-
- gtk_widget_event (widget, fevent);
-
- g_object_notify (G_OBJECT (widget), "has-focus");
+ device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
+ devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
+ devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
+ devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
+
+ for (d = devices; d; d = d->next)
+ {
+ GdkDevice *dev = d->data;
+ GdkEvent *fevent;
+
+ if (dev->source != GDK_SOURCE_KEYBOARD)
+ continue;
+
+ /* Skip non-master keyboards that haven't
+ * selected for events from this window
+ */
+ if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
+ widget->window &&
+ !gdk_window_get_device_events (widget->window, dev))
+ continue;
+
+ fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+
+ fevent->focus_change.type = GDK_FOCUS_CHANGE;
+ fevent->focus_change.window = widget->window;
+ if (widget->window)
+ g_object_ref (widget->window);
+ fevent->focus_change.in = in;
+ gdk_event_set_device (fevent, dev);
+
+ gtk_widget_send_focus_change (widget, fevent);
+
+ gdk_event_free (fevent);
+ }
+
+ g_list_free (devices);
g_object_unref (widget);
- gdk_event_free (fevent);
}
static gint
* 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);
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
GtkBin *bin;
GtkWindow *window;
GtkContainer *container;
+ GtkWidget *child;
GtkWidget *old_focus_child;
GtkWidget *parent;
window = GTK_WINDOW (widget);
bin = GTK_BIN (widget);
- old_focus_child = container->focus_child;
+ old_focus_child = gtk_container_get_focus_child (container);
/* We need a special implementation here to deal properly with wrapping
* around in the tab chain without the danger of going into an
}
/* Now try to focus the first widget in the window */
- if (bin->child)
+ child = gtk_bin_get_child (bin);
+ if (child)
{
- if (gtk_widget_child_focus (bin->child, direction))
+ if (gtk_widget_child_focus (child, direction))
return TRUE;
}
{
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);
+ _gtk_widget_set_has_default (window->focus_widget, FALSE);
gtk_widget_queue_draw (window->focus_widget);
if (window->default_widget)
- GTK_WIDGET_SET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
+ _gtk_widget_set_has_default (window->default_widget, TRUE);
}
window->focus_widget = NULL;
{
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))
- GTK_WIDGET_SET_FLAGS (window->focus_widget, GTK_HAS_DEFAULT);
+ if (gtk_widget_get_can_default (window->focus_widget))
+ _gtk_widget_set_has_default (window->focus_widget, TRUE);
if (window->default_widget)
- GTK_WIDGET_UNSET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
+ _gtk_widget_set_has_default (window->default_widget, FALSE);
}
if (window->has_focus)
* 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));
}
}
+
+static void
+gtk_window_size_request_init (GtkSizeRequestIface *iface)
+{
+ iface->get_width = gtk_window_get_width;
+ iface->get_height = gtk_window_get_height;
+}
+
+
+static void
+gtk_window_get_width (GtkSizeRequest *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_size_request_get_width (GTK_SIZE_REQUEST (child), &child_min, &child_nat);
+
+ *minimum_size += child_min;
+ *natural_size += child_nat;
+ }
+}
+
+static void
+gtk_window_get_height (GtkSizeRequest *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_size_request_get_height (GTK_SIZE_REQUEST (child), &child_min, &child_nat);
+
+ *minimum_size += child_min;
+ *natural_size += child_nat;
+ }
+}
+
+
/**
* _gtk_window_unset_focus_and_default:
* @window: a #GtkWindow
g_object_ref (window);
g_object_ref (widget);
- if (GTK_CONTAINER (widget->parent)->focus_child == widget)
+ if (gtk_container_get_focus_child (GTK_CONTAINER (widget->parent)) == widget)
{
child = window->focus_widget;
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;
gint monitor_num;
GdkScreen *window_screen;
GdkScreen *pointer_screen;
+ GdkDisplay *display;
+ GdkDeviceManager *device_manager;
+ GdkDevice *pointer;
window_screen = gtk_window_check_screen (window);
- gdk_display_get_pointer (gdk_screen_get_display (window_screen),
- &pointer_screen,
- &px, &py, NULL);
+ display = gdk_screen_get_display (window_screen);
+ device_manager = gdk_display_get_device_manager (display);
+ pointer = gdk_device_manager_get_client_pointer (device_manager);
+
+ gdk_display_get_device_state (display, pointer,
+ &pointer_screen,
+ &px, &py, NULL);
if (pointer_screen == window_screen)
monitor_num = gdk_screen_get_monitor_at_point (pointer_screen, px, py);
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,
gint screen_height = gdk_screen_get_height (screen);
gint monitor_num;
GdkRectangle monitor;
+ GdkDisplay *display;
+ GdkDeviceManager *device_manager;
+ GdkDevice *pointer;
GdkScreen *pointer_screen;
gint px, py;
-
- gdk_display_get_pointer (gdk_screen_get_display (screen),
- &pointer_screen,
- &px, &py, NULL);
+
+ display = gdk_screen_get_display (screen);
+ device_manager = gdk_display_get_device_manager (display);
+ pointer = gdk_device_manager_get_client_pointer (device_manager);
+
+ gdk_display_get_device_state (display, pointer,
+ &pointer_screen,
+ &px, &py, NULL);
if (pointer_screen == screen)
monitor_num = gdk_screen_get_monitor_at_point (screen, px, py);
gdk_window_process_updates (widget->window, TRUE);
- if (container->resize_mode == GTK_RESIZE_QUEUE)
+ if (gtk_container_get_resize_mode (container) == GTK_RESIZE_QUEUE)
gtk_widget_queue_draw (widget);
}
else
* FIXME: we should also dequeue the pending redraws here, since
* we handle those ourselves upon ->configure_notify_received==TRUE.
*/
- if (container->resize_mode == GTK_RESIZE_QUEUE)
+ if (gtk_container_get_resize_mode (container) == GTK_RESIZE_QUEUE)
{
gtk_widget_queue_resize_no_redraw (widget);
_gtk_container_dequeue_resize_handler (container);
else
new_geometry->min_height += extra_height;
}
- else if (!window->allow_shrink)
+ else
{
*new_flags |= GDK_HINT_MIN_SIZE;
else
new_geometry->max_height += extra_height;
}
- else if (!window->allow_grow)
+ else if (!window->resizable)
{
*new_flags |= GDK_HINT_MAX_SIZE;
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)
gboolean setting)
{
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (!GTK_WIDGET_REALIZED (window));
+ g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window)));
window->has_frame = setting != FALSE;
}
window->frame_right = right;
window->frame_bottom = bottom;
- if (GTK_WIDGET_REALIZED (widget) && window->frame)
+ if (gtk_widget_get_realized (widget) && window->frame)
{
gint width = widget->allocation.width + left + right;
gint height = widget->allocation.height + top + bottom;
widget = GTK_WIDGET (window);
- if (GTK_WIDGET_VISIBLE (window))
+ if (gtk_widget_get_visible (widget))
{
g_assert (widget->window != NULL);
{
g_return_if_fail (GTK_IS_WINDOW (window));
- gtk_window_set_policy_internal (window, FALSE, resizable, FALSE);
+ window->resizable = (resizable != FALSE);
+
+ g_object_notify (G_OBJECT (window), "resizable");
+
+ gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
}
/**
* mean by "resizable" (and will be a reliable indicator if
* set_policy() hasn't been called)
*/
- return window->allow_grow;
+ return window->resizable;
}
/**
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: (out) (allow-none): location to store the width of the frame at the left, or %NULL
+ * @top: (out) (allow-none): location to store the height of the frame at the top, or %NULL
+ * @right: (out) (allow-none): location to store the width of the frame at the returns, or %NULL
+ * @bottom: (out) (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);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_widget_unrealize (widget);
gtk_window_free_key_hash (window);
static void
gtk_window_group_class_init (GtkWindowGroupClass *klass)
{
+ g_type_class_add_private (klass, sizeof (GtkWindowGroupPrivate));
}
GType
window_group_cleanup_grabs (GtkWindowGroup *group,
GtkWindow *window)
{
+ GtkWindowGroupPrivate *priv;
+ GtkDeviceGrabInfo *info;
GSList *tmp_list;
GSList *to_remove = NULL;
g_object_unref (to_remove->data);
to_remove = g_slist_delete_link (to_remove, to_remove);
}
+
+ priv = GTK_WINDOW_GROUP_GET_PRIVATE (group);
+ tmp_list = priv->device_grabs;
+
+ while (tmp_list)
+ {
+ info = tmp_list->data;
+
+ if (gtk_widget_get_toplevel (info->widget) == (GtkWidget *) window)
+ to_remove = g_slist_prepend (to_remove, info);
+
+ tmp_list = tmp_list->next;
+ }
+
+ while (to_remove)
+ {
+ info = to_remove->data;
+
+ gtk_device_grab_remove (info->widget, info->device);
+ to_remove = g_slist_delete_link (to_remove, to_remove);
+ }
}
/**
/**
* 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
}
}
-/* Return the current grab widget of the given group
+/**
+ * gtk_window_has_group:
+ * @window: a #GtkWindow
+ *
+ * Returns whether @window has an explicit window group.
+ *
+ * Return value: %TRUE if @window has an explicit window group.
+ *
+ * Since 2.22
+ **/
+gboolean
+gtk_window_has_group (GtkWindow *window)
+{
+ g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
+
+ return window->group != NULL;
+}
+
+/**
+ * gtk_window_group_get_current_grab:
+ * @window_group: a #GtkWindowGroup
+ *
+ * Gets the current grab widget of the given group,
+ * see gtk_grab_add().
+ *
+ * Returns: the current grab widget of the group
+ *
+ * Since: 2.22
*/
GtkWidget *
-_gtk_window_group_get_current_grab (GtkWindowGroup *window_group)
+gtk_window_group_get_current_grab (GtkWindowGroup *window_group)
{
+ g_return_val_if_fail (GTK_IS_WINDOW_GROUP (window_group), NULL);
+
if (window_group->grabs)
return GTK_WIDGET (window_group->grabs->data);
return NULL;
}
+void
+_gtk_window_group_add_device_grab (GtkWindowGroup *window_group,
+ GtkWidget *widget,
+ GdkDevice *device,
+ gboolean block_others)
+{
+ GtkWindowGroupPrivate *priv;
+ GtkDeviceGrabInfo *info;
+
+ priv = GTK_WINDOW_GROUP_GET_PRIVATE (window_group);
+
+ info = g_slice_new0 (GtkDeviceGrabInfo);
+ info->widget = widget;
+ info->device = device;
+ info->block_others = block_others;
+
+ priv->device_grabs = g_slist_prepend (priv->device_grabs, info);
+}
+
+void
+_gtk_window_group_remove_device_grab (GtkWindowGroup *window_group,
+ GtkWidget *widget,
+ GdkDevice *device)
+{
+ GtkWindowGroupPrivate *priv;
+ GtkDeviceGrabInfo *info;
+ GSList *list, *node = NULL;
+ GdkDevice *other_device;
+
+ priv = GTK_WINDOW_GROUP_GET_PRIVATE (window_group);
+ other_device = gdk_device_get_associated_device (device);
+ list = priv->device_grabs;
+
+ while (list)
+ {
+ info = list->data;
+
+ if (info->widget == widget &&
+ (info->device == device ||
+ info->device == other_device))
+ {
+ node = list;
+ break;
+ }
+
+ list = list->next;
+ }
+
+ if (node)
+ {
+ info = node->data;
+
+ priv->device_grabs = g_slist_delete_link (priv->device_grabs, node);
+ g_slice_free (GtkDeviceGrabInfo, info);
+ }
+}
+
+/**
+ * gtk_window_group_get_current_device_grab:
+ * @window_group: a #GtkWindowGroup
+ * @device: a #GdkDevice
+ *
+ * Returns the current grab widget for @device, or %NULL if none.
+ *
+ * Returns: The grab widget, or %NULL
+ **/
+GtkWidget *
+gtk_window_group_get_current_device_grab (GtkWindowGroup *window_group,
+ GdkDevice *device)
+{
+ GtkWindowGroupPrivate *priv;
+ GtkDeviceGrabInfo *info;
+ GdkDevice *other_device;
+ GSList *list;
+
+ g_return_val_if_fail (GTK_IS_WINDOW_GROUP (window_group), NULL);
+ g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
+
+ priv = GTK_WINDOW_GROUP_GET_PRIVATE (window_group);
+ list = priv->device_grabs;
+ other_device = gdk_device_get_associated_device (device);
+
+ while (list)
+ {
+ info = list->data;
+ list = list->next;
+
+ if (info->device == device ||
+ info->device == other_device)
+ return info->widget;
+ }
+
+ return NULL;
+}
+
+gboolean
+_gtk_window_group_widget_is_blocked_for_device (GtkWindowGroup *window_group,
+ GtkWidget *widget,
+ GdkDevice *device)
+{
+ GtkWindowGroupPrivate *priv;
+ GtkDeviceGrabInfo *info;
+ GdkDevice *other_device;
+ GSList *list;
+
+ priv = GTK_WINDOW_GROUP_GET_PRIVATE (window_group);
+ other_device = gdk_device_get_associated_device (device);
+ list = priv->device_grabs;
+
+ while (list)
+ {
+ info = list->data;
+ list = list->next;
+
+ /* Look for blocking grabs on other device pairs
+ * that have the passed widget within the GTK+ grab.
+ */
+ if (info->block_others &&
+ info->device != device &&
+ info->device != other_device &&
+ (info->widget == widget ||
+ gtk_widget_is_ancestor (widget, info->widget)))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
/*
Derived from XParseGeometry() in XFree86
GtkAccelGroup *group = groups->data;
gint i;
- for (i = 0; i < group->n_accels; i++)
+ for (i = 0; i < group->priv->n_accels; i++)
{
- GtkAccelKey *key = &group->priv_accels[i].key;
+ GtkAccelKey *key = &group->priv->priv_accels[i].key;
if (key->accel_key)
(*func) (window, key->accel_key, key->accel_mods, FALSE, func_data);
{
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 (GtkWindow *window,
gboolean is_toplevel)
{
- if (GTK_WIDGET_TOPLEVEL (window))
+ GtkWidget *widget;
+
+ widget = GTK_WIDGET (window);
+
+ if (gtk_widget_is_toplevel (widget))
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 (widget))
return;
if (is_toplevel)
{
- GTK_WIDGET_SET_FLAGS (window, GTK_TOPLEVEL);
+ _gtk_widget_set_is_toplevel (widget, TRUE);
toplevel_list = g_slist_prepend (toplevel_list, window);
}
else
{
- GTK_WIDGET_UNSET_FLAGS (window, GTK_TOPLEVEL);
+ _gtk_widget_set_is_toplevel (widget, FALSE);
toplevel_list = g_slist_remove (toplevel_list, window);
}
}
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)
{
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)
}
#endif
-
-#define __GTK_WINDOW_C__
-#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff