* Boston, MA 02111-1307, USA.
*/
+#include "config.h"
+#include <string.h>
#include "gtkcontainer.h"
#include "gtkintl.h"
#include "gtkprivate.h"
#include "gtksizegroup.h"
+#include "gtkbuildable.h"
+#include "gtkalias.h"
enum {
PROP_0,
- PROP_MODE
+ PROP_MODE,
+ PROP_IGNORE_HIDDEN
};
static void gtk_size_group_set_property (GObject *object,
GSList **groups,
GSList **widgets);
+/* GtkBuildable */
+static void gtk_size_group_buildable_init (GtkBuildableIface *iface);
+static gboolean gtk_size_group_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data);
+static void gtk_size_group_buildable_custom_finished (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer user_data);
+
static GQuark size_groups_quark;
-static const gchar *size_groups_tag = "gtk-size-groups";
+static const gchar size_groups_tag[] = "gtk-size-groups";
+
+static GQuark visited_quark;
+static const gchar visited_tag[] = "gtk-size-group-visited";
static GSList *
get_size_groups (GtkWidget *widget)
{
- if (!size_groups_quark)
- size_groups_quark = g_quark_from_string (size_groups_tag);
-
return g_object_get_qdata (G_OBJECT (widget), size_groups_quark);
}
set_size_groups (GtkWidget *widget,
GSList *groups)
{
- if (!size_groups_quark)
- size_groups_quark = g_quark_from_string (size_groups_tag);
-
g_object_set_qdata (G_OBJECT (widget), size_groups_quark, groups);
}
+static void
+mark_visited (gpointer object)
+{
+ g_object_set_qdata (object, visited_quark, "visited");
+}
+
+static void
+mark_unvisited (gpointer object)
+{
+ g_object_set_qdata (object, visited_quark, NULL);
+}
+
+static gboolean
+is_visited (gpointer object)
+{
+ return g_object_get_qdata (object, visited_quark) != NULL;
+}
+
static void
add_group_to_closure (GtkSizeGroup *group,
GtkSizeGroupMode mode,
GSList *tmp_widgets;
*groups = g_slist_prepend (*groups, group);
+ mark_visited (group);
tmp_widgets = group->widgets;
while (tmp_widgets)
{
GtkWidget *tmp_widget = tmp_widgets->data;
- if (!g_slist_find (*widgets, tmp_widget))
+ if (!is_visited (tmp_widget))
add_widget_to_closure (tmp_widget, mode, groups, widgets);
tmp_widgets = tmp_widgets->next;
GSList *tmp_groups;
*widgets = g_slist_prepend (*widgets, widget);
+ mark_visited (widget);
tmp_groups = get_size_groups (widget);
while (tmp_groups)
GtkSizeGroup *tmp_group = tmp_groups->data;
if ((tmp_group->mode == GTK_SIZE_GROUP_BOTH || tmp_group->mode == mode) &&
- !g_slist_find (*groups, tmp_group))
+ !is_visited (tmp_group))
add_group_to_closure (tmp_group, mode, groups, widgets);
tmp_groups = tmp_groups->next;
if (widget->parent)
_gtk_container_queue_resize (GTK_CONTAINER (widget->parent));
- else if (GTK_WIDGET_TOPLEVEL (widget) && GTK_IS_CONTAINER (widget))
+ else if (gtk_widget_is_toplevel (widget) && GTK_IS_CONTAINER (widget))
_gtk_container_queue_resize (GTK_CONTAINER (widget));
}
widgets = NULL;
add_widget_to_closure (parent, GTK_SIZE_GROUP_HORIZONTAL, &groups, &widgets);
+ g_slist_foreach (widgets, (GFunc)mark_unvisited, NULL);
+ g_slist_foreach (groups, (GFunc)mark_unvisited, NULL);
+
reset_group_sizes (groups);
tmp_list = widgets;
if (widget == parent)
real_queue_resize (parent);
}
+ else if (tmp_list->data == widget)
+ {
+ g_warning ("A container and its child are part of this SizeGroup");
+ }
else
queue_resize_on_widget (tmp_list->data, FALSE);
widgets = NULL;
add_widget_to_closure (parent, GTK_SIZE_GROUP_VERTICAL, &groups, &widgets);
+ g_slist_foreach (widgets, (GFunc)mark_unvisited, NULL);
+ g_slist_foreach (groups, (GFunc)mark_unvisited, NULL);
+
reset_group_sizes (groups);
tmp_list = widgets;
if (widget == parent)
real_queue_resize (parent);
}
+ else if (tmp_list->data == widget)
+ {
+ g_warning ("A container and its child are part of this SizeGroup");
+ }
else
queue_resize_on_widget (tmp_list->data, FALSE);
queue_resize_on_widget (size_group->widgets->data, TRUE);
}
+static void
+initialize_size_group_quarks (void)
+{
+ if (!size_groups_quark)
+ {
+ size_groups_quark = g_quark_from_static_string (size_groups_tag);
+ visited_quark = g_quark_from_static_string (visited_tag);
+ }
+}
+
static void
gtk_size_group_class_init (GtkSizeGroupClass *klass)
{
g_object_class_install_property (gobject_class,
PROP_MODE,
g_param_spec_enum ("mode",
- _("Mode"),
- _("The directions in which the size group effects the requested sizes"
+ P_("Mode"),
+ P_("The directions in which the size group affects the requested sizes"
" of its component widgets"),
GTK_TYPE_SIZE_GROUP_MODE,
- GTK_SIZE_GROUP_HORIZONTAL,
- G_PARAM_READWRITE));
+ GTK_SIZE_GROUP_HORIZONTAL, GTK_PARAM_READWRITE));
+
+ /**
+ * GtkSizeGroup:ignore-hidden:
+ *
+ * If %TRUE, unmapped widgets are ignored when determining
+ * the size of the group.
+ *
+ * Since: 2.8
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_IGNORE_HIDDEN,
+ g_param_spec_boolean ("ignore-hidden",
+ P_("Ignore hidden"),
+ P_("If TRUE, unmapped widgets are ignored "
+ "when determining the size of the group"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
+ initialize_size_group_quarks ();
}
static void
size_group->mode = GTK_SIZE_GROUP_HORIZONTAL;
size_group->have_width = 0;
size_group->have_height = 0;
+ size_group->ignore_hidden = 0;
}
-GType
-gtk_size_group_get_type (void)
+static void
+gtk_size_group_buildable_init (GtkBuildableIface *iface)
{
- static GType size_group_type = 0;
-
- if (!size_group_type)
- {
- static const GTypeInfo size_group_info =
- {
- sizeof (GtkSizeGroupClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) gtk_size_group_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GtkSizeGroup),
- 16, /* n_preallocs */
- (GInstanceInitFunc) gtk_size_group_init,
- };
-
- size_group_type = g_type_register_static (G_TYPE_OBJECT, "GtkSizeGroup",
- &size_group_info, 0);
- }
-
- return size_group_type;
+ iface->custom_tag_start = gtk_size_group_buildable_custom_tag_start;
+ iface->custom_finished = gtk_size_group_buildable_custom_finished;
}
+G_DEFINE_TYPE_WITH_CODE (GtkSizeGroup, gtk_size_group, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+ gtk_size_group_buildable_init))
+
static void
gtk_size_group_set_property (GObject *object,
guint prop_id,
case PROP_MODE:
gtk_size_group_set_mode (size_group, g_value_get_enum (value));
break;
+ case PROP_IGNORE_HIDDEN:
+ gtk_size_group_set_ignore_hidden (size_group, g_value_get_boolean (value));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
case PROP_MODE:
g_value_set_enum (value, size_group->mode);
break;
+ case PROP_IGNORE_HIDDEN:
+ g_value_set_boolean (value, size_group->ignore_hidden);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
* Return value: a newly created #GtkSizeGroup
**/
GtkSizeGroup *
-gtk_size_group_new (GtkSizeGroupMode mode)
+gtk_size_group_new (GtkSizeGroupMode mode)
{
GtkSizeGroup *size_group = g_object_new (GTK_TYPE_SIZE_GROUP, NULL);
return size_group->mode;
}
+/**
+ * gtk_size_group_set_ignore_hidden:
+ * @size_group: a #GtkSizeGroup
+ * @ignore_hidden: whether unmapped widgets should be ignored
+ * when calculating the size
+ *
+ * Sets whether unmapped widgets should be ignored when
+ * calculating the size.
+ *
+ * Since: 2.8
+ */
+void
+gtk_size_group_set_ignore_hidden (GtkSizeGroup *size_group,
+ gboolean ignore_hidden)
+{
+ g_return_if_fail (GTK_IS_SIZE_GROUP (size_group));
+
+ ignore_hidden = ignore_hidden != FALSE;
+
+ if (size_group->ignore_hidden != ignore_hidden)
+ {
+ size_group->ignore_hidden = ignore_hidden;
+
+ g_object_notify (G_OBJECT (size_group), "ignore-hidden");
+ }
+}
+
+/**
+ * gtk_size_group_get_ignore_hidden:
+ * @size_group: a #GtkSizeGroup
+ *
+ * Returns if invisible widgets are ignored when calculating the size.
+ *
+ * Returns: %TRUE if invisible widgets are ignored.
+ *
+ * Since: 2.8
+ */
+gboolean
+gtk_size_group_get_ignore_hidden (GtkSizeGroup *size_group)
+{
+ g_return_val_if_fail (GTK_IS_SIZE_GROUP (size_group), FALSE);
+
+ return size_group->ignore_hidden;
+}
+
static void
gtk_size_group_widget_destroyed (GtkWidget *widget,
GtkSizeGroup *size_group)
* and the requisition of the other widgets in the size group.
* Whether this applies horizontally, vertically, or in both directions
* depends on the mode of the size group. See gtk_size_group_set_mode().
- **/
+ *
+ * When the widget is destroyed or no longer referenced elsewhere, it will
+ * be removed from the size group.
+ */
void
gtk_size_group_add_widget (GtkSizeGroup *size_group,
GtkWidget *widget)
groups = get_size_groups (widget);
- if (!g_slist_find (groups, widget))
+ if (!g_slist_find (groups, size_group))
{
groups = g_slist_prepend (groups, size_group);
set_size_groups (widget, groups);
* Removes a widget from a #GtkSizeGroup.
**/
void
-gtk_size_group_remove_widget (GtkSizeGroup *size_group,
- GtkWidget *widget)
+gtk_size_group_remove_widget (GtkSizeGroup *size_group,
+ GtkWidget *widget)
{
GSList *groups;
g_object_unref (size_group);
}
+/**
+ * gtk_size_group_get_widgets:
+ * @size_group: a #GtkSizeGrup
+ *
+ * Returns the list of widgets associated with @size_group.
+ *
+ * Return value: (element-type GtkWidget) (transfer none): a #GSList of
+ * widgets. The list is owned by GTK+ and should not be modified.
+ *
+ * Since: 2.10
+ **/
+GSList *
+gtk_size_group_get_widgets (GtkSizeGroup *size_group)
+{
+ return size_group->widgets;
+}
+
static gint
get_base_dimension (GtkWidget *widget,
GtkSizeGroupMode mode)
{
if (GTK_WIDGET_REQUEST_NEEDED (widget))
{
- gtk_widget_ensure_style (widget);
+ gtk_widget_ensure_style (widget);
+ GTK_PRIVATE_UNSET_FLAG (widget, GTK_REQUEST_NEEDED);
g_signal_emit_by_name (widget,
- "size_request",
+ "size-request",
&widget->requisition);
-
- GTK_PRIVATE_UNSET_FLAG (widget, GTK_REQUEST_NEEDED);
}
}
add_widget_to_closure (widget, mode, &groups, &widgets);
+ g_slist_foreach (widgets, (GFunc)mark_unvisited, NULL);
+ g_slist_foreach (groups, (GFunc)mark_unvisited, NULL);
+
g_slist_foreach (widgets, (GFunc)g_object_ref, NULL);
if (!groups)
gint dimension = compute_base_dimension (tmp_widget, mode);
- if (dimension > result)
- result = dimension;
-
+ if (gtk_widget_get_mapped (tmp_widget) || !group->ignore_hidden)
+ {
+ if (dimension > result)
+ result = dimension;
+ }
+
tmp_list = tmp_list->next;
}
}
g_slist_foreach (widgets, (GFunc)g_object_unref, NULL);
-
+
g_slist_free (widgets);
g_slist_free (groups);
add_widget_to_closure (widget, mode, &groups, &widgets);
+ g_slist_foreach (widgets, (GFunc)mark_unvisited, NULL);
+ g_slist_foreach (groups, (GFunc)mark_unvisited, NULL);
+
if (!groups)
{
result = get_base_dimension (widget, mode);
_gtk_size_group_get_child_requisition (GtkWidget *widget,
GtkRequisition *requisition)
{
+ initialize_size_group_quarks ();
+
if (requisition)
{
if (get_size_groups (widget))
gint width;
gint height;
+ initialize_size_group_quarks ();
+
if (get_size_groups (widget))
{
/* Only do the full computation if we actually have size groups */
void
_gtk_size_group_queue_resize (GtkWidget *widget)
{
+ initialize_size_group_quarks ();
+
queue_resize_on_widget (widget, TRUE);
}
+
+typedef struct {
+ GObject *object;
+ GSList *items;
+} GSListSubParserData;
+
+static void
+size_group_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, "widget") == 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, "widgets") == 0)
+ return;
+ else
+ g_warning ("Unsupported type tag for GtkSizeGroup: %s\n",
+ element_name);
+
+}
+
+static const GMarkupParser size_group_parser =
+ {
+ size_group_start_element
+ };
+
+static gboolean
+gtk_size_group_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data)
+{
+ GSListSubParserData *parser_data;
+
+ if (child)
+ return FALSE;
+
+ if (strcmp (tagname, "widgets") == 0)
+ {
+ parser_data = g_slice_new0 (GSListSubParserData);
+ parser_data->items = NULL;
+ parser_data->object = G_OBJECT (buildable);
+
+ *parser = size_group_parser;
+ *data = parser_data;
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+gtk_size_group_buildable_custom_finished (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer user_data)
+{
+ GSList *l;
+ GSListSubParserData *data;
+ GObject *object;
+
+ if (strcmp (tagname, "widgets"))
+ return;
+
+ data = (GSListSubParserData*)user_data;
+ data->items = g_slist_reverse (data->items);
+
+ for (l = data->items; l; l = l->next)
+ {
+ object = gtk_builder_get_object (builder, l->data);
+ if (!object)
+ {
+ g_warning ("Unknown object %s specified in sizegroup %s",
+ (const gchar*)l->data,
+ gtk_buildable_get_name (GTK_BUILDABLE (data->object)));
+ continue;
+ }
+ gtk_size_group_add_widget (GTK_SIZE_GROUP (data->object),
+ GTK_WIDGET (object));
+ g_free (l->data);
+ }
+ g_slist_free (data->items);
+ g_slice_free (GSListSubParserData, data);
+}
+
+
+#define __GTK_SIZE_GROUP_C__
+#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff