* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#include <config.h>
+#include "config.h"
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include "gtkcontainer.h"
+#include "gtkbuildable.h"
+#include "gtkbuilderprivate.h"
#include "gtkprivate.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtktoolbar.h"
#include <gobject/gobjectnotifyqueue.c>
#include <gobject/gvaluecollector.h>
+#include "gtkalias.h"
enum {
static gchar* gtk_container_child_default_composite_name (GtkContainer *container,
GtkWidget *child);
+/* GtkBuildable */
+static void gtk_container_buildable_init (GtkBuildableIface *iface);
+static void gtk_container_buildable_add_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *type);
+static gboolean gtk_container_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data);
+static void gtk_container_buildable_custom_tag_end (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer *data);
+
/* --- variables --- */
-static const gchar *vadjustment_key = "gtk-vadjustment";
+static const gchar vadjustment_key[] = "gtk-vadjustment";
static guint vadjustment_key_id = 0;
-static const gchar *hadjustment_key = "gtk-hadjustment";
+static const gchar hadjustment_key[] = "gtk-hadjustment";
static guint hadjustment_key_id = 0;
static GSList *container_resize_queue = NULL;
static guint container_signals[LAST_SIGNAL] = { 0 };
static GtkWidgetClass *parent_class = NULL;
extern GParamSpecPool *_gtk_widget_child_property_pool;
extern GObjectNotifyContext *_gtk_widget_child_property_notify_context;
+static GtkBuildableIface *parent_buildable_iface;
/* --- functions --- */
if (!container_type)
{
- static const GTypeInfo container_info =
+ const GTypeInfo container_info =
{
sizeof (GtkContainerClass),
(GBaseInitFunc) gtk_container_base_class_init,
NULL, /* value_table */
};
+ const GInterfaceInfo buildable_info =
+ {
+ (GInterfaceInitFunc) gtk_container_buildable_init,
+ NULL,
+ NULL
+ };
+
container_type =
- g_type_register_static (GTK_TYPE_WIDGET, "GtkContainer",
+ g_type_register_static (GTK_TYPE_WIDGET, I_("GtkContainer"),
&container_info, G_TYPE_FLAG_ABSTRACT);
+
+ g_type_add_interface_static (container_type,
+ GTK_TYPE_BUILDABLE,
+ &buildable_info);
+
}
return container_type;
g_object_class_install_property (gobject_class,
PROP_RESIZE_MODE,
- g_param_spec_enum ("resize_mode",
+ g_param_spec_enum ("resize-mode",
P_("Resize mode"),
P_("Specify how resize events are handled"),
GTK_TYPE_RESIZE_MODE,
GTK_RESIZE_PARENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_BORDER_WIDTH,
- g_param_spec_uint ("border_width",
+ g_param_spec_uint ("border-width",
P_("Border width"),
P_("The width of the empty border outside the containers children"),
0,
- G_MAXINT,
+ 65535,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CHILD,
g_param_spec_object ("child",
P_("Child"),
P_("Can be used to add a new child to the container"),
GTK_TYPE_WIDGET,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
container_signals[ADD] =
- g_signal_new ("add",
+ g_signal_new (I_("add"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkContainerClass, add),
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
container_signals[REMOVE] =
- g_signal_new ("remove",
+ g_signal_new (I_("remove"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkContainerClass, remove),
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
container_signals[CHECK_RESIZE] =
- g_signal_new ("check_resize",
+ g_signal_new (I_("check-resize"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkContainerClass, check_resize),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
container_signals[SET_FOCUS_CHILD] =
- g_signal_new ("set-focus-child",
+ g_signal_new (I_("set-focus-child"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkContainerClass, set_focus_child),
GTK_TYPE_WIDGET);
}
+static void
+gtk_container_buildable_init (GtkBuildableIface *iface)
+{
+ parent_buildable_iface = g_type_interface_peek_parent (iface);
+ iface->add_child = gtk_container_buildable_add_child;
+ iface->custom_tag_start = gtk_container_buildable_custom_tag_start;
+ iface->custom_tag_end = gtk_container_buildable_custom_tag_end;
+}
+
+static void
+gtk_container_buildable_add_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *type)
+{
+ if (type)
+ {
+ GTK_BUILDER_WARN_INVALID_CHILD_TYPE (buildable, type);
+ }
+ else if (GTK_IS_WIDGET (child) && GTK_WIDGET (child)->parent == NULL)
+ {
+ gtk_container_add (GTK_CONTAINER (buildable), GTK_WIDGET (child));
+ }
+ else
+ g_warning ("Cannot add an object of type %s to a container of type %s",
+ g_type_name (G_OBJECT_TYPE (child)), g_type_name (G_OBJECT_TYPE (buildable)));
+}
+
+static void
+gtk_container_buildable_set_child_property (GtkContainer *container,
+ GtkBuilder *builder,
+ GtkWidget *child,
+ gchar *name,
+ const gchar *value)
+{
+ GParamSpec *pspec;
+ GValue gvalue = { 0, };
+ GError *error = NULL;
+
+ pspec = gtk_container_class_find_child_property
+ (G_OBJECT_GET_CLASS (container), name);
+ if (!pspec)
+ {
+ g_warning ("%s does not have a property called %s",
+ g_type_name (G_OBJECT_TYPE (container)), name);
+ return;
+ }
+
+ if (!gtk_builder_value_from_string (builder, pspec, value, &gvalue, &error))
+ {
+ g_warning ("Could not read property %s:%s with value %s of type %s: %s",
+ g_type_name (G_OBJECT_TYPE (container)),
+ name,
+ value,
+ g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
+ error->message);
+ g_error_free (error);
+ return;
+ }
+
+ gtk_container_child_set_property (container, child, name, &gvalue);
+ g_value_unset (&gvalue);
+}
+
+typedef struct {
+ GtkBuilder *builder;
+ GtkContainer *container;
+ GtkWidget *child;
+ gchar *child_prop_name;
+ gchar *context;
+ gboolean translatable;
+} PackingPropertiesData;
+
+static void
+attributes_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **names,
+ const gchar **values,
+ gpointer user_data,
+ GError **error)
+{
+ PackingPropertiesData *parser_data = (PackingPropertiesData*)user_data;
+ guint i;
+
+ if (strcmp (element_name, "property") == 0)
+ {
+ for (i = 0; names[i]; i++)
+ if (strcmp (names[i], "name") == 0)
+ parser_data->child_prop_name = g_strdup (values[i]);
+ else if (strcmp (names[i], "translatable") == 0)
+ {
+ if (!_gtk_builder_boolean_from_string (values[1],
+ &parser_data->translatable,
+ error))
+ return;
+ }
+ else if (strcmp (names[i], "comments") == 0)
+ ; /* for translators */
+ else if (strcmp (names[i], "context") == 0)
+ parser_data->context = g_strdup (values[1]);
+ else
+ g_warning ("Unsupported attribute for GtkContainer Child "
+ "property: %s\n", names[i]);
+ }
+ else if (strcmp (element_name, "packing") == 0)
+ return;
+ else
+ g_warning ("Unsupported tag for GtkContainer: %s\n", element_name);
+}
+
+static void
+attributes_text_element (GMarkupParseContext *context,
+ const gchar *text,
+ gsize text_len,
+ gpointer user_data,
+ GError **error)
+{
+ PackingPropertiesData *parser_data = (PackingPropertiesData*)user_data;
+ gchar* value;
+
+ if (!parser_data->child_prop_name)
+ return;
+
+ if (parser_data->translatable && text_len)
+ {
+ const gchar* domain;
+ domain = gtk_builder_get_translation_domain (parser_data->builder);
+
+ value = _gtk_builder_parser_translate (domain,
+ parser_data->context,
+ text);
+ }
+ else
+ {
+ value = g_strdup (text);
+ }
+
+ gtk_container_buildable_set_child_property (parser_data->container,
+ parser_data->builder,
+ parser_data->child,
+ parser_data->child_prop_name,
+ value);
+
+ g_free (parser_data->child_prop_name);
+ g_free (parser_data->context);
+ g_free (value);
+ parser_data->child_prop_name = NULL;
+ parser_data->context = NULL;
+ parser_data->translatable = FALSE;
+}
+
+static const GMarkupParser attributes_parser =
+ {
+ attributes_start_element,
+ NULL,
+ attributes_text_element,
+ };
+
+static gboolean
+gtk_container_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data)
+{
+ PackingPropertiesData *parser_data;
+
+ if (parent_buildable_iface->custom_tag_start (buildable, builder, child,
+ tagname, parser, data))
+ return TRUE;
+
+ if (child && strcmp (tagname, "packing") == 0)
+ {
+ parser_data = g_slice_new0 (PackingPropertiesData);
+ parser_data->builder = builder;
+ parser_data->container = GTK_CONTAINER (buildable);
+ parser_data->child = GTK_WIDGET (child);
+ parser_data->child_prop_name = NULL;
+
+ *parser = attributes_parser;
+ *data = parser_data;
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+gtk_container_buildable_custom_tag_end (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer *data)
+{
+ if (strcmp (tagname, "packing") == 0)
+ {
+ g_slice_free (PackingPropertiesData, (gpointer)data);
+ return;
+
+ }
+
+ if (parent_buildable_iface->custom_tag_end)
+ parent_buildable_iface->custom_tag_end (buildable, builder,
+ child, tagname, data);
+
+}
+
/**
* gtk_container_child_type:
- * @container: a #GtkContainer.
+ * @container: a #GtkContainer
*
* Returns the type of the children supported by the container.
*
* @container: a #GtkContainer
* @child: a widget which is a child of @container
* @first_property_name: the name of the first property to get
- * @var_args: a %NULL-terminated list of property names and #GValue*,
- * starting with @first_prop_name.
+ * @var_args: return location for the first property, followed
+ * optionally by more name/return location pairs, followed by %NULL
*
* Gets the values of one or more child properties for @child and @container.
**/
* @child: a widget which is a child of @container
* @first_property_name: the name of the first property to set
* @var_args: a %NULL-terminated list of property names and values, starting
- * with @first_prop_name.
+ * with @first_prop_name
*
* Sets one or more child properties for @child and @container.
**/
const gchar *first_property_name,
va_list var_args)
{
- GObject *object;
GObjectNotifyQueue *nqueue;
const gchar *name;
g_object_ref (container);
g_object_ref (child);
- object = G_OBJECT (container);
nqueue = g_object_notify_queue_freeze (G_OBJECT (child), _gtk_widget_child_property_notify_context);
name = first_property_name;
while (name)
const gchar *property_name,
const GValue *value)
{
- GObject *object;
GObjectNotifyQueue *nqueue;
GParamSpec *pspec;
g_object_ref (container);
g_object_ref (child);
- object = G_OBJECT (container);
nqueue = g_object_notify_queue_freeze (G_OBJECT (child), _gtk_widget_child_property_notify_context);
pspec = g_param_spec_pool_lookup (_gtk_widget_child_property_pool, property_name,
G_OBJECT_TYPE (container), TRUE);
* @widget: a widget to be placed inside @container
* @first_prop_name: the name of the first child property to set
* @Varargs: a %NULL-terminated list of property names and values, starting
- * with @first_prop_name.
+ * with @first_prop_name
*
* Adds @widget to @container, setting child properties at the same time.
* See gtk_container_add() and gtk_container_child_set() for more details.
* @child: a widget which is a child of @container
* @first_prop_name: the name of the first property to set
* @Varargs: a %NULL-terminated list of property names and values, starting
- * with @first_prop_name.
+ * with @first_prop_name
*
* Sets one or more child properties for @child and @container.
**/
* @container: a #GtkContainer
* @child: a widget which is a child of @container
* @first_prop_name: the name of the first property to get
- * @Varargs: a %NULL-terminated list of property names and #GValue*,
- * starting with @first_prop_name.
+ * @Varargs: return location for the first property, followed
+ * optionally by more name/return location pairs, followed by %NULL
*
* Gets the values of one or more child properties for @child and @container.
**/
* gtk_container_class_find_child_property:
* @cclass: a #GtkContainerClass
* @property_name: the name of the child property to find
- * @returns: the #GParamSpec of the child property or %NULL if @class has no
+ * @returns: (allow-none): the #GParamSpec of the child property or %NULL if @class has no
* child property with that name.
*
* Finds a child property of a container class by name.
* gtk_container_class_list_child_properties:
* @cclass: a #GtkContainerClass
* @n_properties: location to return the number of child properties found
- * @returns: a newly allocated array of #GParamSpec*. The array must be
- * freed with g_free().
+ * @returns: a newly allocated %NULL-terminated array of #GParamSpec*.
+ * The array must be freed with g_free().
*
* Returns all child properties of a container class.
*/
gtk_container_destroy (GtkObject *object)
{
GtkContainer *container = GTK_CONTAINER (object);
-
+
if (GTK_CONTAINER_RESIZE_PENDING (container))
_gtk_container_dequeue_resize_handler (container);
*/
if (container->has_focus_chain)
gtk_container_unset_focus_chain (container);
-
+
gtk_container_foreach (container, (GtkCallback) gtk_widget_destroy, NULL);
-
- if (GTK_OBJECT_CLASS (parent_class)->destroy)
- (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
/**
* gtk_container_set_border_width:
* @container: a #GtkContainer
- * @border_width: amount of blank space to leave <emphasis>outside</emphasis> the container.
- * Valid values are in the range 0-65535 pixels.
+ * @border_width: amount of blank space to leave <emphasis>outside</emphasis>
+ * the container. Valid values are in the range 0-65535 pixels.
*
* Sets the border width of the container.
*
* #GtkWindow; because toplevel windows can't leave space outside,
* they leave the space inside. The border is added on all sides of
* the container. To add space to only one side, one approach is to
- * create a #GtkAlignment widget, call gtk_widget_set_usize() to give
- * it a size, and place it on the side of the container as a spacer.
+ * create a #GtkAlignment widget, call gtk_widget_set_size_request()
+ * to give it a size, and place it on the side of the container as
+ * a spacer.
**/
void
gtk_container_set_border_width (GtkContainer *container,
if (container->border_width != border_width)
{
container->border_width = border_width;
- g_object_notify (G_OBJECT (container), "border_width");
+ g_object_notify (G_OBJECT (container), "border-width");
if (GTK_WIDGET_REALIZED (container))
gtk_widget_queue_resize (GTK_WIDGET (container));
{
g_warning ("Attempting to add a widget with type %s to a container of "
"type %s, but the widget is already inside a container of type %s, "
- "the GTK+ FAQ at http://www.gtk.org/faq/ explains how to reparent a widget.",
+ "the GTK+ FAQ at http://library.gnome.org/devel/gtk-faq/stable/ "
+ "explains how to reparent a widget.",
g_type_name (G_OBJECT_TYPE (widget)),
g_type_name (G_OBJECT_TYPE (container)),
g_type_name (G_OBJECT_TYPE (widget->parent)));
/**
* gtk_container_set_resize_mode:
- * @container: a #GtkContainer.
- * @resize_mode: the new resize mode.
+ * @container: a #GtkContainer
+ * @resize_mode: the new resize mode
*
* Sets the resize mode for the container.
*
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (resize_mode <= GTK_RESIZE_IMMEDIATE);
- if (GTK_WIDGET_TOPLEVEL (container) &&
+ if (gtk_widget_is_toplevel (GTK_WIDGET (container)) &&
resize_mode == GTK_RESIZE_PARENT)
{
resize_mode = GTK_RESIZE_QUEUE;
container->resize_mode = resize_mode;
gtk_widget_queue_resize (GTK_WIDGET (container));
- g_object_notify (G_OBJECT (container), "resize_mode");
+ g_object_notify (G_OBJECT (container), "resize-mode");
}
}
/**
* gtk_container_set_reallocate_redraws:
- * @container: a #GtkContainer.
- * @needs_redraws: the new value for the container's @reallocate_redraws flag.
+ * @container: a #GtkContainer
+ * @needs_redraws: the new value for the container's @reallocate_redraws flag
*
* Sets the @reallocate_redraws flag of the container to the given value.
*
static gboolean
gtk_container_idle_sizer (gpointer data)
{
- GDK_THREADS_ENTER ();
-
/* we may be invoked with a container_resize_queue of NULL, because
* queue_resize could have been adding an extra idle function while
* the queue still got processed. we better just ignore such case
gdk_window_process_all_updates ();
- GDK_THREADS_LEAVE ();
-
return FALSE;
}
widget = GTK_WIDGET (container);
resize_container = gtk_container_get_resize_container (container);
- while (!GTK_WIDGET_ALLOC_NEEDED (widget) || !GTK_WIDGET_REQUEST_NEEDED (widget))
+ while (TRUE)
{
GTK_PRIVATE_SET_FLAG (widget, GTK_ALLOC_NEEDED);
GTK_PRIVATE_SET_FLAG (widget, GTK_REQUEST_NEEDED);
if (resize_container)
{
- if (GTK_WIDGET_VISIBLE (resize_container) &&
- (GTK_WIDGET_TOPLEVEL (resize_container) || GTK_WIDGET_REALIZED (resize_container)))
+ if (gtk_widget_get_visible (GTK_WIDGET (resize_container)) &&
+ (gtk_widget_is_toplevel (GTK_WIDGET (resize_container)) || GTK_WIDGET_REALIZED (resize_container)))
{
switch (resize_container->resize_mode)
{
{
GTK_PRIVATE_SET_FLAG (resize_container, GTK_RESIZE_PENDING);
if (container_resize_queue == NULL)
- g_idle_add_full (GTK_PRIORITY_RESIZE,
+ gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE,
gtk_container_idle_sizer,
NULL, NULL);
container_resize_queue = g_slist_prepend (container_resize_queue, resize_container);
* @callback: a callback
* @callback_data: callback user data
*
- * Invokes @callback on each non-internal child of @container. See
+ * Invokes @callback on each non-internal child of @container. See
* gtk_container_forall() for details on what constitutes an
* "internal" child. Most applications should use
* gtk_container_foreach(), rather than gtk_container_forall().
GtkCallback callback,
GtkCallbackMarshal marshal,
gpointer callback_data,
- GtkDestroyNotify notify)
+ GDestroyNotify notify)
{
g_return_if_fail (GTK_IS_CONTAINER (container));
notify (callback_data);
}
+/**
+ * gtk_container_set_focus_child:
+ * @container: a #GtkContainer
+ * @child: (allow-none): a #GtkWidget, or %NULL
+ *
+ * Sets, or unsets if @child is %NULL, the focused child of @container.
+ *
+ * This function emits the GtkContainer::set_focus_child signal of
+ * @container. Implementations of #GtkContainer can override the
+ * default behaviour by overriding the class closure of this signal.
+ */
void
gtk_container_set_focus_child (GtkContainer *container,
- GtkWidget *widget)
+ GtkWidget *child)
{
g_return_if_fail (GTK_IS_CONTAINER (container));
- if (widget)
- g_return_if_fail (GTK_IS_WIDGET (widget));
+ if (child)
+ g_return_if_fail (GTK_IS_WIDGET (child));
- g_signal_emit (container, container_signals[SET_FOCUS_CHILD], 0, widget);
+ g_signal_emit (container, container_signals[SET_FOCUS_CHILD], 0, child);
+}
+
+/**
+ * gtk_container_get_focus_child:
+ * @container: a #GtkContainer
+ *
+ * Returns the current focus child widget inside @container.
+ *
+ * Returns: The child widget which has the focus
+ * inside @container, or %NULL if none is set.
+ *
+ * Since: 2.14
+ **/
+GtkWidget *
+gtk_container_get_focus_child (GtkContainer *container)
+{
+ g_return_val_if_fail (GTK_IS_CONTAINER (container), NULL);
+
+ return container->focus_child;
}
/**
* gtk_container_get_children:
- * @container: a #GtkContainer.
+ * @container: a #GtkContainer
*
- * Returns the the container's non-internal children. See
- * gtk_container_forall() for details on what constitutes an "internal" child.
+ * Returns the container's non-internal children. See
+ * gtk_container_forall() for details on what constitutes an "internal" child.
*
- * Return value: a newly-allocated list of the container's non-internal children.
+ * Return value: (element-type GtkWidget) (transfer container): a newly-allocated list of the container's non-internal children.
**/
GList*
gtk_container_get_children (GtkContainer *container)
_gtk_container_child_composite_name (GtkContainer *container,
GtkWidget *child)
{
+ gboolean composite_child;
+
g_return_val_if_fail (GTK_IS_CONTAINER (container), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
g_return_val_if_fail (child->parent == GTK_WIDGET (container), NULL);
- if (GTK_WIDGET_COMPOSITE_CHILD (child))
+ g_object_get (child, "composite-child", &composite_child, NULL);
+ if (composite_child)
{
static GQuark quark_composite_name = 0;
gchar *name;
return_val = FALSE;
- if (GTK_WIDGET_CAN_FOCUS (container))
+ if (gtk_widget_get_can_focus (widget))
{
- if (!GTK_WIDGET_HAS_FOCUS (container))
+ if (!gtk_widget_has_focus (widget))
{
- gtk_widget_grab_focus (GTK_WIDGET (container));
+ gtk_widget_grab_focus (widget);
return_val = TRUE;
}
}
{
GtkWidget *widget = GTK_WIDGET (container);
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
-
- if (toplevel && GTK_IS_WINDOW (toplevel) && GTK_WINDOW (toplevel)->focus_widget)
+
+ if (GTK_IS_WINDOW (toplevel) && GTK_WINDOW (toplevel)->focus_widget)
{
GtkWidget *old_focus = GTK_WINDOW (toplevel)->focus_widget;
CompareInfo *compare = data;
gint y1, y2;
- if (!get_allocation_coords (compare->container, (GtkWidget *)a, &allocation1))
- return 0;
- if (!get_allocation_coords (compare->container, (GtkWidget *)b, &allocation2))
- return 0;
+ get_allocation_coords (compare->container, (GtkWidget *)a, &allocation1);
+ get_allocation_coords (compare->container, (GtkWidget *)b, &allocation2);
y1 = allocation1.y + allocation1.height / 2;
y2 = allocation2.y + allocation2.height / 2;
}
else
{
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
compare.x = widget->allocation.x + widget->allocation.width / 2;
else
compare.x = widget->allocation.width / 2;
}
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
compare.y = (direction == GTK_DIR_DOWN) ? widget->allocation.y : widget->allocation.y + widget->allocation.height;
else
compare.y = (direction == GTK_DIR_DOWN) ? 0 : + widget->allocation.height;
CompareInfo *compare = data;
gint x1, x2;
- if (!get_allocation_coords (compare->container, (GtkWidget *)a, &allocation1))
- return 0;
- if (!get_allocation_coords (compare->container, (GtkWidget *)b, &allocation2))
- return 0;
+ get_allocation_coords (compare->container, (GtkWidget *)a, &allocation1);
+ get_allocation_coords (compare->container, (GtkWidget *)b, &allocation2);
x1 = allocation1.x + allocation1.width / 2;
x2 = allocation2.x + allocation2.width / 2;
}
else
{
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
compare.y = widget->allocation.y + widget->allocation.height / 2;
else
compare.y = widget->allocation.height / 2;
}
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
compare.x = (direction == GTK_DIR_RIGHT) ? widget->allocation.x : widget->allocation.x + widget->allocation.width;
else
compare.x = (direction == GTK_DIR_RIGHT) ? 0 : widget->allocation.width;
* gtk_container_focus_sort:
* @container: a #GtkContainer
* @children: a list of descendents of @container (they don't
- * have to be direct children.
+ * have to be direct children)
* @direction: focus direction
- * @old_focus: widget to use for the starting position, or %NULL
+ * @old_focus: (allow-none): widget to use for the starting position, or %NULL
* to determine this automatically.
- * [ Note, this argument isn't used for GTK_DIR_TAB_*,
- * which is the only @direction we use currently,
- * so perhaps this argument should be removed ]
+ * (Note, this argument isn't used for GTK_DIR_TAB_*,
+ * which is the only @direction we use currently,
+ * so perhaps this argument should be removed)
*
* Sorts @children in the correct order for focusing with
* direction type @direction.
GtkDirectionType direction,
GtkWidget *old_focus)
{
- children = g_list_copy (children);
+ GList *visible_children = NULL;
+
+ while (children)
+ {
+ if (GTK_WIDGET_REALIZED (children->data))
+ visible_children = g_list_prepend (visible_children, children->data);
+ children = children->next;
+ }
switch (direction)
{
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_TAB_BACKWARD:
- return gtk_container_focus_sort_tab (container, children, direction, old_focus);
+ return gtk_container_focus_sort_tab (container, visible_children, direction, old_focus);
case GTK_DIR_UP:
case GTK_DIR_DOWN:
- return gtk_container_focus_sort_up_down (container, children, direction, old_focus);
+ return gtk_container_focus_sort_up_down (container, visible_children, direction, old_focus);
case GTK_DIR_LEFT:
case GTK_DIR_RIGHT:
- return gtk_container_focus_sort_left_right (container, children, direction, old_focus);
+ return gtk_container_focus_sort_left_right (container, visible_children, direction, old_focus);
}
g_assert_not_reached ();
return TRUE;
}
}
- else if (GTK_WIDGET_DRAWABLE (child) &&
+ else if (gtk_widget_is_drawable (child) &&
gtk_widget_is_ancestor (child, GTK_WIDGET (container)))
{
if (gtk_widget_child_focus (child, direction))
user_data);
g_object_set_data (G_OBJECT (container),
- "gtk-container-focus-chain",
+ I_("gtk-container-focus-chain"),
chain);
}
/**
* gtk_container_set_focus_chain:
- * @container: a #GtkContainer.
- * @focusable_widgets: the new focus chain.
+ * @container: a #GtkContainer
+ * @focusable_widgets: the new focus chain
*
* Sets a focus chain, overriding the one computed automatically by GTK+.
*
chain = g_list_reverse (chain);
g_object_set_data (G_OBJECT (container),
- "gtk-container-focus-chain",
+ I_("gtk-container-focus-chain"),
chain);
}
/**
* gtk_container_get_focus_chain:
* @container: a #GtkContainer
- * @focusable_widgets: location to store the focus chain of the
+ * @focusable_widgets: (element-type GtkWidget) (out) (transfer container): location
+ * to store the focus chain of the
* container, or %NULL. You should free this list
* using g_list_free() when you are done with it, however
* no additional reference count is added to the
/**
* gtk_container_unset_focus_chain:
- * @container: a #GtkContainer.
+ * @container: a #GtkContainer
*
* Removes a focus chain explicitly set with gtk_container_set_focus_chain().
**/
container->has_focus_chain = FALSE;
- g_object_set_data (G_OBJECT (container), "gtk-container-focus-chain",
+ g_object_set_data (G_OBJECT (container),
+ I_("gtk-container-focus-chain"),
NULL);
tmp_list = chain;
/**
* gtk_container_set_focus_vadjustment:
* @container: a #GtkContainer
- * @adjustment: an adjustment which should be adjusted when the focus is moved among the
- * descendents of @container
+ * @adjustment: an adjustment which should be adjusted when the focus
+ * is moved among the descendents of @container
*
- * Hooks up an adjustment to focus handling in a container, so when a child of the
- * container is focused, the adjustment is scrolled to show that widget. This function
- * sets the vertical alignment. See gtk_scrolled_window_get_vadjustment() for a typical
- * way of obtaining the adjustment and gtk_container_set_focus_hadjustment() for setting
+ * Hooks up an adjustment to focus handling in a container, so when a
+ * child of the container is focused, the adjustment is scrolled to
+ * show that widget. This function sets the vertical alignment. See
+ * gtk_scrolled_window_get_vadjustment() for a typical way of obtaining
+ * the adjustment and gtk_container_set_focus_hadjustment() for setting
* the horizontal adjustment.
*
- * The adjustments have to be in pixel units and in the same coordinate system as the
- * allocation for immediate children of the container.
+ * The adjustments have to be in pixel units and in the same coordinate
+ * system as the allocation for immediate children of the container.
*/
void
gtk_container_set_focus_vadjustment (GtkContainer *container,
* @container: a #GtkContainer
*
* Retrieves the vertical focus adjustment for the container. See
- * gtk_container_set_focus_vadjustment ().
+ * gtk_container_set_focus_vadjustment().
*
- * Return value: the vertical focus adjustment, or %NULL if
+ * Return value: (transfer none): the vertical focus adjustment, or %NULL if
* none has been set.
**/
GtkAdjustment *
/**
* gtk_container_set_focus_hadjustment:
* @container: a #GtkContainer
- * @adjustment: an adjustment which should be adjusted when the focus is moved among the
- * descendents of @container
+ * @adjustment: an adjustment which should be adjusted when the focus is
+ * moved among the descendents of @container
*
- * Hooks up an adjustment to focus handling in a container, so when a child of the
- * container is focused, the adjustment is scrolled to show that widget. This function
- * sets the horizontal alignment. See gtk_scrolled_window_get_hadjustment() for a typical
- * way of obtaining the adjustment and gtk_container_set_focus_vadjustment() for setting
+ * Hooks up an adjustment to focus handling in a container, so when a child
+ * of the container is focused, the adjustment is scrolled to show that
+ * widget. This function sets the horizontal alignment.
+ * See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining
+ * the adjustment and gtk_container_set_focus_vadjustment() for setting
* the vertical adjustment.
*
- * The adjustments have to be in pixel units and in the same coordinate system as the
- * allocation for immediate children of the container.
+ * The adjustments have to be in pixel units and in the same coordinate
+ * system as the allocation for immediate children of the container.
*/
void
gtk_container_set_focus_hadjustment (GtkContainer *container,
* Retrieves the horizontal focus adjustment for the container. See
* gtk_container_set_focus_hadjustment ().
*
- * Return value: the horizontal focus adjustment, or %NULL if
+ * Return value: (transfer none): the horizontal focus adjustment, or %NULL if
* none has been set.
**/
GtkAdjustment *
g_return_val_if_fail (event != NULL, FALSE);
- if (GTK_WIDGET_DRAWABLE (widget))
+ if (gtk_widget_is_drawable (widget))
{
data.container = widget;
data.event = event;
gtk_container_map_child (GtkWidget *child,
gpointer client_data)
{
- if (GTK_WIDGET_VISIBLE (child) &&
+ if (gtk_widget_get_visible (child) &&
GTK_WIDGET_CHILD_VISIBLE (child) &&
!GTK_WIDGET_MAPPED (child))
gtk_widget_map (child);
gtk_container_map_child,
NULL);
- if (!GTK_WIDGET_NO_WINDOW (widget))
+ if (gtk_widget_get_has_window (widget))
gdk_window_show (widget->window);
}
{
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
- if (!GTK_WIDGET_NO_WINDOW (widget))
+ if (gtk_widget_get_has_window (widget))
gdk_window_hide (widget->window);
else
gtk_container_forall (GTK_CONTAINER (widget),
* the event's area with the child area, and sending the event.
*
* In most cases, a container can simply either simply inherit the
- * ::expose implementation from #GtkContainer, or, do some drawing
+ * #GtkWidget::expose implementation from #GtkContainer, or, do some drawing
* and then chain to the ::expose implementation from #GtkContainer.
**/
void
g_assert (child->parent == GTK_WIDGET (container));
- if (GTK_WIDGET_DRAWABLE (child) &&
- GTK_WIDGET_NO_WINDOW (child) &&
+ if (gtk_widget_is_drawable (child) &&
+ !gtk_widget_get_has_window (child) &&
(child->window == event->window))
{
child_event = gdk_event_new (GDK_EXPOSE);
gdk_event_free (child_event);
}
}
+
+#define __GTK_CONTAINER_C__
+#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff