summaryrefslogtreecommitdiff
path: root/eel/eel-wrap-table.c
diff options
context:
space:
mode:
authorPerberos <[email protected]>2011-12-01 22:24:23 -0300
committerPerberos <[email protected]>2011-12-01 22:24:23 -0300
commit0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree43261e815529cb9518ed7be37af13b846af8b26b /eel/eel-wrap-table.c
downloadcaja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2
caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz
moving from https://github.com/perberos/mate-desktop-environment
Diffstat (limited to 'eel/eel-wrap-table.c')
-rw-r--r--eel/eel-wrap-table.c1108
1 files changed, 1108 insertions, 0 deletions
diff --git a/eel/eel-wrap-table.c b/eel/eel-wrap-table.c
new file mode 100644
index 00000000..12325a14
--- /dev/null
+++ b/eel/eel-wrap-table.c
@@ -0,0 +1,1108 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* eel-wrap-box.c - A table that can wrap its contents as needed.
+
+ Copyright (C) 2000 Eazel, Inc.
+
+ The Mate Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The Mate Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the Mate Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+
+ Authors: Ramiro Estrugo <[email protected]>
+*/
+
+#include <config.h>
+#include "eel-wrap-table.h"
+
+#include "eel-art-extensions.h"
+#include "eel-art-gtk-extensions.h"
+#include "eel-gtk-extensions.h"
+#include "eel-gtk-macros.h"
+#include "eel-types.h"
+#include <gtk/gtk.h>
+
+/* Arguments */
+enum
+{
+ PROP_0,
+ PROP_X_SPACING,
+ PROP_Y_SPACING,
+ PROP_X_JUSTIFICATION,
+ PROP_Y_JUSTIFICATION,
+ PROP_HOMOGENEOUS
+};
+
+/* Detail member struct */
+struct EelWrapTableDetails
+{
+ guint x_spacing;
+ guint y_spacing;
+ EelJustification x_justification;
+ EelJustification y_justification;
+ gboolean homogeneous;
+ GList *children;
+
+ guint is_scrolled : 1;
+ guint cols;
+};
+
+static void eel_wrap_table_class_init (EelWrapTableClass *wrap_table_class);
+static void eel_wrap_table_init (EelWrapTable *wrap);
+/* GObjectClass methods */
+static void eel_wrap_table_finalize (GObject *object);
+static void eel_wrap_table_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void eel_wrap_table_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
+/* GtkWidgetClass methods */
+static void eel_wrap_table_size_request (GtkWidget *widget,
+ GtkRequisition *requisition);
+static int eel_wrap_table_expose_event (GtkWidget *widget,
+ GdkEventExpose *event);
+static void eel_wrap_table_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation);
+static void eel_wrap_table_map (GtkWidget *widget);
+static void eel_wrap_table_unmap (GtkWidget *widget);
+static void eel_wrap_table_realize (GtkWidget *widget);
+
+/* GtkContainerClass methods */
+static void eel_wrap_table_add (GtkContainer *container,
+ GtkWidget *widget);
+static void eel_wrap_table_remove (GtkContainer *container,
+ GtkWidget *widget);
+static void eel_wrap_table_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data);
+static GType eel_wrap_table_child_type (GtkContainer *container);
+
+
+/* Private EelWrapTable methods */
+static EelDimensions wrap_table_irect_max_dimensions (const EelDimensions *one,
+ const EelDimensions *two);
+static EelDimensions wrap_table_get_max_child_dimensions (const EelWrapTable *wrap_table);
+static EelDimensions wrap_table_get_content_dimensions (const EelWrapTable *wrap_table);
+static EelIRect wrap_table_get_content_bounds (const EelWrapTable *wrap_table);
+static gboolean wrap_table_child_focus_in (GtkWidget *widget,
+ GdkEventFocus *event,
+ gpointer data);
+static void wrap_table_layout (EelWrapTable *wrap_table);
+
+
+EEL_CLASS_BOILERPLATE (EelWrapTable, eel_wrap_table, GTK_TYPE_CONTAINER)
+
+/* Class init methods */
+static void
+eel_wrap_table_class_init (EelWrapTableClass *wrap_table_class)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (wrap_table_class);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (wrap_table_class);
+ GtkContainerClass *container_class = GTK_CONTAINER_CLASS (wrap_table_class);
+
+ /* GObjectClass */
+ gobject_class->finalize = eel_wrap_table_finalize;
+ gobject_class->set_property = eel_wrap_table_set_property;
+ gobject_class->get_property = eel_wrap_table_get_property;
+
+ /* GtkWidgetClass */
+ widget_class->size_request = eel_wrap_table_size_request;
+ widget_class->size_allocate = eel_wrap_table_size_allocate;
+ widget_class->expose_event = eel_wrap_table_expose_event;
+ widget_class->map = eel_wrap_table_map;
+ widget_class->unmap = eel_wrap_table_unmap;
+ widget_class->realize = eel_wrap_table_realize;
+
+ /* GtkContainerClass */
+ container_class->add = eel_wrap_table_add;
+ container_class->remove = eel_wrap_table_remove;
+ container_class->forall = eel_wrap_table_forall;
+ container_class->child_type = eel_wrap_table_child_type;
+
+ /* Register some the enum types we need */
+ eel_type_init ();
+
+ /* Arguments */
+ g_object_class_install_property
+ (gobject_class,
+ PROP_X_SPACING,
+ g_param_spec_uint ("x_spacing", NULL, NULL,
+ 0, G_MAXINT, 0, G_PARAM_READWRITE));
+
+ g_object_class_install_property
+ (gobject_class,
+ PROP_Y_SPACING,
+ g_param_spec_uint ("y_spacing", NULL, NULL,
+ 0, G_MAXINT, 0, G_PARAM_READWRITE));
+
+ g_object_class_install_property
+ (gobject_class,
+ PROP_X_JUSTIFICATION,
+ g_param_spec_enum ("x_justification", NULL, NULL,
+ EEL_TYPE_JUSTIFICATION,
+ EEL_JUSTIFICATION_BEGINNING,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property
+ (gobject_class,
+ PROP_Y_JUSTIFICATION,
+ g_param_spec_enum ("y_justification", NULL, NULL,
+ EEL_TYPE_JUSTIFICATION,
+ EEL_JUSTIFICATION_BEGINNING,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property
+ (gobject_class,
+ PROP_HOMOGENEOUS,
+ g_param_spec_boolean ("homogenous", NULL, NULL,
+ FALSE, G_PARAM_READWRITE));
+}
+
+static void
+eel_wrap_table_init (EelWrapTable *wrap_table)
+{
+ gtk_widget_set_has_window (GTK_WIDGET (wrap_table), FALSE);
+
+ wrap_table->details = g_new0 (EelWrapTableDetails, 1);
+ wrap_table->details->x_justification = EEL_JUSTIFICATION_BEGINNING;
+ wrap_table->details->y_justification = EEL_JUSTIFICATION_END;
+ wrap_table->details->cols = 1;
+}
+
+static void
+eel_wrap_table_finalize (GObject *object)
+{
+ EelWrapTable *wrap_table;
+
+ wrap_table = EEL_WRAP_TABLE (object);
+
+ g_list_free (wrap_table->details->children);
+ g_free (wrap_table->details);
+
+ EEL_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+/* GObjectClass methods */
+
+static void
+eel_wrap_table_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ EelWrapTable *wrap_table;
+
+ g_assert (EEL_IS_WRAP_TABLE (object));
+
+ wrap_table = EEL_WRAP_TABLE (object);
+
+ switch (property_id)
+ {
+ case PROP_X_SPACING:
+ eel_wrap_table_set_x_spacing (wrap_table, g_value_get_uint (value));
+ break;
+
+ case PROP_Y_SPACING:
+ eel_wrap_table_set_y_spacing (wrap_table, g_value_get_uint (value));
+ break;
+
+ case PROP_X_JUSTIFICATION:
+ eel_wrap_table_set_x_justification (wrap_table, g_value_get_enum (value));
+ break;
+
+ case PROP_Y_JUSTIFICATION:
+ eel_wrap_table_set_y_justification (wrap_table, g_value_get_enum (value));
+ break;
+
+ case PROP_HOMOGENEOUS:
+ eel_wrap_table_set_homogeneous (wrap_table, g_value_get_boolean (value));
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+static void
+eel_wrap_table_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ EelWrapTable *wrap_table;
+
+ g_assert (EEL_IS_WRAP_TABLE (object));
+
+ wrap_table = EEL_WRAP_TABLE (object);
+
+ switch (property_id)
+ {
+ case PROP_X_SPACING:
+ g_value_set_uint (value, eel_wrap_table_get_x_spacing (wrap_table));
+ break;
+
+ case PROP_Y_SPACING:
+ g_value_set_uint (value, eel_wrap_table_get_y_spacing (wrap_table));
+ break;
+
+ case PROP_X_JUSTIFICATION:
+ g_value_set_enum (value, eel_wrap_table_get_x_justification (wrap_table));
+ break;
+
+ case PROP_Y_JUSTIFICATION:
+ g_value_set_enum (value, eel_wrap_table_get_y_justification (wrap_table));
+ break;
+
+ case PROP_HOMOGENEOUS:
+ g_value_set_boolean (value, eel_wrap_table_get_homogeneous (wrap_table));
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+/* GtkWidgetClass methods */
+static void
+eel_wrap_table_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ EelWrapTable *wrap_table;
+ EelDimensions content_dimensions;
+
+ g_assert (EEL_IS_WRAP_TABLE (widget));
+ g_assert (requisition != NULL);
+
+ wrap_table = EEL_WRAP_TABLE (widget);
+
+ content_dimensions = wrap_table_get_content_dimensions (wrap_table);
+
+ /* The -1 tells Satan to use as much space as is available */
+ requisition->width = -1;
+ requisition->height = content_dimensions.height + gtk_container_get_border_width (GTK_CONTAINER (widget)) * 2;
+}
+
+static void
+eel_wrap_table_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ EelWrapTable *wrap_table;
+
+ g_assert (EEL_IS_WRAP_TABLE (widget));
+ g_assert (allocation != NULL);
+
+ wrap_table = EEL_WRAP_TABLE (widget);
+
+ gtk_widget_set_allocation (widget, allocation);
+
+ wrap_table_layout (wrap_table);
+}
+
+static int
+eel_wrap_table_expose_event (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ EelWrapTable *wrap_table;
+ GList *iterator;
+
+ g_assert (EEL_IS_WRAP_TABLE (widget));
+ g_assert (gtk_widget_get_realized (widget));
+ g_assert (event != NULL);
+
+ wrap_table = EEL_WRAP_TABLE (widget);
+
+ for (iterator = wrap_table->details->children; iterator; iterator = iterator->next)
+ {
+ g_assert (GTK_IS_WIDGET (iterator->data));
+ gtk_container_propagate_expose (GTK_CONTAINER (widget),
+ GTK_WIDGET (iterator->data),
+ event);
+ }
+
+ return FALSE;
+}
+
+static void
+eel_wrap_table_map (GtkWidget *widget)
+{
+ EelWrapTable *wrap_table;
+ GList *iterator;
+
+ g_assert (EEL_IS_WRAP_TABLE (widget));
+
+ wrap_table = EEL_WRAP_TABLE (widget);
+
+ gtk_widget_set_mapped (widget, TRUE);
+
+ for (iterator = wrap_table->details->children; iterator; iterator = iterator->next)
+ {
+ GtkWidget *item;
+
+ item = iterator->data;
+
+ if (gtk_widget_get_visible (item) && !gtk_widget_get_mapped (item))
+ {
+ gtk_widget_map (item);
+ }
+ }
+}
+
+static void
+eel_wrap_table_unmap (GtkWidget *widget)
+{
+ EelWrapTable *wrap_table;
+ GList *iterator;
+
+ g_assert (EEL_IS_WRAP_TABLE (widget));
+
+ wrap_table = EEL_WRAP_TABLE (widget);
+
+ gtk_widget_set_mapped (widget, FALSE);
+
+ for (iterator = wrap_table->details->children; iterator; iterator = iterator->next)
+ {
+ GtkWidget *item;
+
+ item = iterator->data;
+
+ if (gtk_widget_get_visible (item) && gtk_widget_get_mapped (item))
+ {
+ gtk_widget_unmap (item);
+ }
+ }
+}
+
+static void
+eel_wrap_table_realize (GtkWidget *widget)
+{
+ g_assert (EEL_IS_WRAP_TABLE (widget));
+
+ GTK_WIDGET_CLASS (parent_class)->realize (widget);
+
+ gtk_widget_queue_resize (widget);
+}
+
+/* GtkContainerClass methods */
+static void
+eel_wrap_table_add (GtkContainer *container,
+ GtkWidget *child)
+{
+ EelWrapTable *wrap_table;
+ GtkWidget *widget;
+
+ g_assert (container != NULL);
+ g_assert (EEL_IS_WRAP_TABLE (container));
+ g_assert (GTK_IS_WIDGET (child));
+
+ widget = GTK_WIDGET (container);
+ wrap_table = EEL_WRAP_TABLE (container);
+
+ gtk_widget_set_parent (child, GTK_WIDGET (container));
+
+ wrap_table->details->children = g_list_append (wrap_table->details->children, child);
+
+ if (gtk_widget_get_realized (widget))
+ {
+ gtk_widget_realize (child);
+ }
+
+ if (gtk_widget_get_visible (widget) && gtk_widget_get_visible (child))
+ {
+ if (gtk_widget_get_mapped (widget))
+ {
+ gtk_widget_map (child);
+ }
+
+ gtk_widget_queue_resize (child);
+ }
+
+ if (wrap_table->details->is_scrolled)
+ {
+ g_signal_connect (child, "focus_in_event",
+ G_CALLBACK (wrap_table_child_focus_in),
+ wrap_table);
+ }
+}
+
+static void
+eel_wrap_table_remove (GtkContainer *container,
+ GtkWidget *child)
+{
+ EelWrapTable *wrap_table;
+ gboolean child_was_visible;
+
+ g_assert (EEL_IS_WRAP_TABLE (container));
+ g_assert (GTK_IS_WIDGET (child));
+
+ wrap_table = EEL_WRAP_TABLE (container);;
+
+ child_was_visible = gtk_widget_get_visible (child);
+ gtk_widget_unparent (child);
+ wrap_table->details->children = g_list_remove (wrap_table->details->children, child);
+
+ if (child_was_visible)
+ {
+ gtk_widget_queue_resize (GTK_WIDGET (container));
+ }
+
+ if (wrap_table->details->is_scrolled)
+ {
+ g_signal_handlers_disconnect_by_func (
+ child,
+ G_CALLBACK (wrap_table_child_focus_in),
+ wrap_table);
+ }
+}
+
+static void
+eel_wrap_table_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ EelWrapTable *wrap_table;
+ GList *node;
+ GList *next;
+
+ g_assert (EEL_IS_WRAP_TABLE (container));
+ g_assert (callback != NULL);
+
+ wrap_table = EEL_WRAP_TABLE (container);;
+
+ for (node = wrap_table->details->children; node != NULL; node = next)
+ {
+ g_assert (GTK_IS_WIDGET (node->data));
+ next = node->next;
+ (* callback) (GTK_WIDGET (node->data), callback_data);
+ }
+}
+
+static GType
+eel_wrap_table_child_type (GtkContainer *container)
+{
+ return GTK_TYPE_WIDGET;
+}
+
+/* Private EelWrapTable methods */
+static int
+wrap_table_get_num_fitting (int available,
+ int spacing,
+ int max_child_size)
+{
+ int num;
+
+ g_assert (max_child_size > 0);
+ g_assert (spacing >= 0);
+
+ available = MAX (available, 0);
+
+ num = (available + spacing) / (max_child_size + spacing);
+ num = MAX (num, 1);
+
+ return num;
+}
+
+static void
+wrap_table_layout (EelWrapTable *wrap_table)
+{
+ GList *iterator;
+ EelIPoint pos;
+ EelDimensions max_child_dimensions;
+ EelIRect content_bounds;
+ guint num_cols;
+ GtkAllocation allocation;
+
+ g_assert (EEL_IS_WRAP_TABLE (wrap_table));
+
+ max_child_dimensions = wrap_table_get_max_child_dimensions (wrap_table);
+ content_bounds = wrap_table_get_content_bounds (wrap_table);
+ pos.x = content_bounds.x0;
+ pos.y = content_bounds.y0;
+
+ gtk_widget_get_allocation (GTK_WIDGET (wrap_table), &allocation);
+ num_cols = wrap_table_get_num_fitting (allocation.width -
+ gtk_container_get_border_width (GTK_CONTAINER (wrap_table)) * 2,
+ wrap_table->details->x_spacing,
+ max_child_dimensions.width);
+ if (num_cols != wrap_table->details->cols)
+ {
+ wrap_table->details->cols = num_cols;
+ gtk_widget_queue_resize (GTK_WIDGET (wrap_table));
+ return;
+ }
+
+ for (iterator = wrap_table->details->children; iterator; iterator = iterator->next)
+ {
+ GtkWidget *item;
+
+ item = iterator->data;
+
+ if (gtk_widget_get_visible (item))
+ {
+ GtkAllocation item_allocation;
+
+ if (wrap_table->details->homogeneous)
+ {
+ item_allocation.x = pos.x;
+ item_allocation.y = pos.y;
+ item_allocation.width = max_child_dimensions.width;
+ item_allocation.height = max_child_dimensions.height;
+
+ if ((pos.x + max_child_dimensions.width) > content_bounds.x1)
+ {
+ pos.x = content_bounds.x0 + wrap_table->details->x_spacing + max_child_dimensions.width;
+ pos.y += (max_child_dimensions.height + wrap_table->details->y_spacing);
+ item_allocation.x = content_bounds.x0;
+ item_allocation.y = pos.y;
+ }
+ else
+ {
+ pos.x += (wrap_table->details->x_spacing + max_child_dimensions.width);
+ }
+ }
+ else
+ {
+ GtkRequisition item_requisition;
+
+ gtk_widget_size_request (item, &item_requisition);
+
+ item_allocation.x = pos.x;
+ item_allocation.y = pos.y;
+ item_allocation.width = item_requisition.width;
+ item_allocation.height = item_requisition.height;
+
+ g_assert (item_allocation.width <= max_child_dimensions.width);
+ g_assert (item_allocation.height <= max_child_dimensions.height);
+
+ if ((pos.x + max_child_dimensions.width) > content_bounds.x1)
+ {
+ pos.x = content_bounds.x0 + wrap_table->details->x_spacing + max_child_dimensions.width;
+ pos.y += (max_child_dimensions.height + wrap_table->details->y_spacing);
+ item_allocation.x = content_bounds.x0;
+ item_allocation.y = pos.y;
+ }
+ else
+ {
+ pos.x += (wrap_table->details->x_spacing + max_child_dimensions.width);
+ }
+
+ switch (wrap_table->details->x_justification)
+ {
+ case EEL_JUSTIFICATION_MIDDLE:
+ item_allocation.x += (max_child_dimensions.width - (int) item_allocation.width) / 2;
+ break;
+ case EEL_JUSTIFICATION_END:
+ item_allocation.x += (max_child_dimensions.width - (int) item_allocation.width);
+ break;
+ default:
+ break;
+ }
+
+ switch (wrap_table->details->y_justification)
+ {
+ case EEL_JUSTIFICATION_MIDDLE:
+ item_allocation.y += (max_child_dimensions.height - (int) item_allocation.height) / 2;
+ break;
+ case EEL_JUSTIFICATION_END:
+ item_allocation.y += (max_child_dimensions.height - (int) item_allocation.height);
+ break;
+ default:
+ break;
+ }
+ }
+
+ gtk_widget_size_allocate (item, &item_allocation);
+ }
+ }
+}
+
+static EelDimensions
+wrap_table_irect_max_dimensions (const EelDimensions *one,
+ const EelDimensions *two)
+{
+ EelDimensions max_dimensions;
+
+ g_assert (one != NULL);
+ g_assert (two != NULL);
+
+ max_dimensions.width = MAX (one->width, two->width);
+ max_dimensions.height = MAX (one->height, two->height);
+
+ return max_dimensions;
+}
+
+static EelDimensions
+wrap_table_get_max_child_dimensions (const EelWrapTable *wrap_table)
+{
+ EelDimensions max_dimensions;
+ GList *iterator;
+
+ g_assert (EEL_IS_WRAP_TABLE (wrap_table));
+
+ max_dimensions = eel_dimensions_empty;
+
+ for (iterator = wrap_table->details->children; iterator; iterator = iterator->next)
+ {
+ GtkWidget *child;
+
+ child = iterator->data;
+
+ if (gtk_widget_get_visible (child))
+ {
+ GtkRequisition child_requisition;
+ EelDimensions child_dimensions;
+
+ gtk_widget_size_request (child, &child_requisition);
+
+ child_dimensions.width = (int) child_requisition.width;
+ child_dimensions.height = (int) child_requisition.height;
+
+ max_dimensions = wrap_table_irect_max_dimensions (&child_dimensions, &max_dimensions);
+ }
+ }
+
+ return max_dimensions;
+}
+
+static EelDimensions
+wrap_table_get_content_dimensions (const EelWrapTable *wrap_table)
+{
+ EelDimensions content_dimensions;
+ guint num_children;
+
+ g_assert (EEL_IS_WRAP_TABLE (wrap_table));
+
+ content_dimensions = eel_dimensions_empty;
+
+ num_children = g_list_length (wrap_table->details->children);
+
+ if (num_children > 0)
+ {
+ EelDimensions max_child_dimensions;
+ EelDimensions dimensions;
+ int num_cols;
+ int num_rows;
+
+ dimensions = eel_gtk_widget_get_dimensions (GTK_WIDGET (wrap_table));
+ max_child_dimensions = wrap_table_get_max_child_dimensions (wrap_table);
+
+ max_child_dimensions.width = MAX (max_child_dimensions.width, 1);
+ max_child_dimensions.height = MAX (max_child_dimensions.height, 1);
+
+ num_cols = wrap_table_get_num_fitting (dimensions.width -
+ gtk_container_get_border_width (GTK_CONTAINER (wrap_table)) * 2,
+ wrap_table->details->x_spacing,
+ max_child_dimensions.width);
+ num_rows = num_children / num_cols;
+ num_rows = MAX (num_rows, 1);
+
+ if ((num_children % num_rows) > 0)
+ {
+ num_rows++;
+ }
+
+ content_dimensions.width = dimensions.width;
+ content_dimensions.height = num_rows * max_child_dimensions.height;
+
+ content_dimensions.width += (num_cols - 1) * wrap_table->details->x_spacing;
+ content_dimensions.height += (num_rows - 1) * wrap_table->details->y_spacing;
+ }
+
+ return content_dimensions;
+}
+
+static EelIRect
+wrap_table_get_content_bounds (const EelWrapTable *wrap_table)
+{
+ EelIRect content_bounds;
+ guint border;
+
+ g_assert (EEL_IS_WRAP_TABLE (wrap_table));
+
+ content_bounds = eel_gtk_widget_get_bounds (GTK_WIDGET (wrap_table));
+
+ border = gtk_container_get_border_width (GTK_CONTAINER (wrap_table));
+ content_bounds.x0 += border;
+ content_bounds.y0 += border;
+ content_bounds.x1 -= border;
+ content_bounds.y1 -= border;
+
+ return content_bounds;
+}
+
+static gboolean
+wrap_table_child_focus_in (GtkWidget *widget,
+ GdkEventFocus *event,
+ gpointer data)
+{
+ GtkWidget *parent, *pparent;
+ GtkAllocation allocation;
+
+ parent = gtk_widget_get_parent (widget);
+ if (parent)
+ pparent = gtk_widget_get_parent (parent);
+ g_assert (parent && pparent);
+ g_assert (GTK_IS_VIEWPORT (pparent));
+
+ gtk_widget_get_allocation (widget, &allocation);
+ eel_gtk_viewport_scroll_to_rect (GTK_VIEWPORT (pparent),
+ &allocation);
+
+ return FALSE;
+}
+
+/**
+ * eel_wrap_table_new:
+ *
+ */
+GtkWidget*
+eel_wrap_table_new (gboolean homogeneous)
+{
+ EelWrapTable *wrap_table;
+
+ wrap_table = EEL_WRAP_TABLE (gtk_widget_new (eel_wrap_table_get_type (), NULL));
+
+ eel_wrap_table_set_homogeneous (wrap_table, homogeneous);
+
+ return GTK_WIDGET (wrap_table);
+}
+
+/**
+ * eel_wrap_table_set_x_spacing:
+ * @wrap_table: A EelWrapTable.
+ * @x_spacing: The new horizontal spacing between wraps.
+ *
+ */
+void
+eel_wrap_table_set_x_spacing (EelWrapTable *wrap_table,
+ guint x_spacing)
+{
+ g_return_if_fail (EEL_IS_WRAP_TABLE (wrap_table));
+
+ if (wrap_table->details->x_spacing == x_spacing)
+ {
+ return;
+ }
+
+ wrap_table->details->x_spacing = x_spacing;
+
+ gtk_widget_queue_resize (GTK_WIDGET (wrap_table));
+}
+
+/**
+ * eel_wrap_table_get_item_spacing:
+ * @wrap_table: A EelWrapTable.
+ *
+ * Returns: The horizontal spacing between wraps.
+ */
+guint
+eel_wrap_table_get_x_spacing (const EelWrapTable *wrap_table)
+{
+ g_return_val_if_fail (EEL_IS_WRAP_TABLE (wrap_table), 0);
+
+ return wrap_table->details->x_spacing;
+}
+
+/**
+ * eel_wrap_table_set_y_spacing:
+ * @wrap_table: A EelWrapTable.
+ * @y_spacing: The new horizontal spacing between wraps.
+ *
+ */
+void
+eel_wrap_table_set_y_spacing (EelWrapTable *wrap_table,
+ guint y_spacing)
+{
+ g_return_if_fail (EEL_IS_WRAP_TABLE (wrap_table));
+
+ if (wrap_table->details->y_spacing == y_spacing)
+ {
+ return;
+ }
+
+ wrap_table->details->y_spacing = y_spacing;
+
+ gtk_widget_queue_resize (GTK_WIDGET (wrap_table));
+}
+
+/**
+ * eel_wrap_table_get_item_spacing:
+ * @wrap_table: A EelWrapTable.
+ *
+ * Returns: The horizontal spacing between wraps.
+ */
+guint
+eel_wrap_table_get_y_spacing (const EelWrapTable *wrap_table)
+{
+ g_return_val_if_fail (EEL_IS_WRAP_TABLE (wrap_table), 0);
+
+ return wrap_table->details->y_spacing;
+}
+
+
+/**
+ * eel_wrap_table_find_child_at_event_point:
+ * @wrap_table: A EelWrapTable.
+ * @x: Event x;
+ * @y: Event y;
+ *
+ * Returns: Child found at given coordinates or NULL of no child is found.
+ */
+GtkWidget *
+eel_wrap_table_find_child_at_event_point (const EelWrapTable *wrap_table,
+ int x,
+ int y)
+{
+ GList *iterator;
+
+ g_return_val_if_fail (EEL_IS_WRAP_TABLE (wrap_table), NULL);
+
+ for (iterator = wrap_table->details->children; iterator; iterator = iterator->next)
+ {
+ GtkWidget *child;
+
+ child = iterator->data;
+
+ if (gtk_widget_get_visible (child))
+ {
+ EelIRect child_bounds;
+
+ child_bounds = eel_gtk_widget_get_bounds (child);
+
+ if (eel_irect_contains_point (child_bounds, x, y))
+ {
+ return child;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+/**
+ * eel_wrap_table_set_x_justification:
+ * @wrap_table: A EelWrapTable.
+ * @x_justification: The new horizontal justification between wraps.
+ *
+ */
+void
+eel_wrap_table_set_x_justification (EelWrapTable *wrap_table,
+ EelJustification x_justification)
+{
+ g_return_if_fail (EEL_IS_WRAP_TABLE (wrap_table));
+ g_return_if_fail (x_justification >= EEL_JUSTIFICATION_BEGINNING);
+ g_return_if_fail (x_justification <= EEL_JUSTIFICATION_END);
+
+ if (wrap_table->details->x_justification == x_justification)
+ {
+ return;
+ }
+
+ wrap_table->details->x_justification = x_justification;
+ gtk_widget_queue_resize (GTK_WIDGET (wrap_table));
+}
+
+/**
+ * eel_wrap_table_get_item_justification:
+ * @wrap_table: A EelWrapTable.
+ *
+ * Returns: The horizontal justification between wraps.
+ */
+EelJustification
+eel_wrap_table_get_x_justification (const EelWrapTable *wrap_table)
+{
+ g_return_val_if_fail (EEL_IS_WRAP_TABLE (wrap_table), 0);
+
+ return wrap_table->details->x_justification;
+}
+
+/**
+ * eel_wrap_table_set_y_justification:
+ * @wrap_table: A EelWrapTable.
+ * @y_justification: The new horizontal justification between wraps.
+ *
+ */
+void
+eel_wrap_table_set_y_justification (EelWrapTable *wrap_table,
+ EelJustification y_justification)
+{
+ g_return_if_fail (EEL_IS_WRAP_TABLE (wrap_table));
+ g_return_if_fail (y_justification >= EEL_JUSTIFICATION_BEGINNING);
+ g_return_if_fail (y_justification <= EEL_JUSTIFICATION_END);
+
+ if (wrap_table->details->y_justification == y_justification)
+ {
+ return;
+ }
+
+ wrap_table->details->y_justification = y_justification;
+ gtk_widget_queue_resize (GTK_WIDGET (wrap_table));
+}
+
+/**
+ * eel_wrap_table_get_item_justification:
+ * @wrap_table: A EelWrapTable.
+ *
+ * Returns: The horizontal justification between wraps.
+ */
+EelJustification
+eel_wrap_table_get_y_justification (const EelWrapTable *wrap_table)
+{
+ g_return_val_if_fail (EEL_IS_WRAP_TABLE (wrap_table), 0);
+
+ return wrap_table->details->y_justification;
+}
+
+/**
+ * eel_wrap_table_set_homogeneous:
+ * @wrap_table: A EelWrapTable.
+ * @homogeneous: The new horizontal spacing between wraps.
+ *
+ */
+void
+eel_wrap_table_set_homogeneous (EelWrapTable *wrap_table,
+ gboolean homogeneous)
+{
+ g_return_if_fail (EEL_IS_WRAP_TABLE (wrap_table));
+
+ if (wrap_table->details->homogeneous == homogeneous)
+ {
+ return;
+ }
+
+ wrap_table->details->homogeneous = homogeneous;
+
+ gtk_widget_queue_resize (GTK_WIDGET (wrap_table));
+}
+
+/**
+ * eel_wrap_table_get_item_spacing:
+ * @wrap_table: A EelWrapTable.
+ *
+ * Returns: The horizontal spacing between wraps.
+ */
+gboolean
+eel_wrap_table_get_homogeneous (const EelWrapTable *wrap_table)
+{
+ g_return_val_if_fail (EEL_IS_WRAP_TABLE (wrap_table), FALSE);
+
+ return wrap_table->details->homogeneous;
+}
+
+/**
+ * eel_wrap_table_reorder_child:
+ * @wrap_table: A EelWrapTable.
+ * @child: Child to reorder.
+ * @position: New position to put child at.
+ *
+ * Reorder the given chilren into the given position.
+ *
+ * Position is interpreted as follows:
+ *
+ * 0 - Place child at start of table.
+ * -1 - Place child at end of table.
+ * n - Place child at nth position. Count starts at 0.
+ */
+void
+eel_wrap_table_reorder_child (EelWrapTable *wrap_table,
+ GtkWidget *child,
+ int position)
+{
+ GList *node;
+ gboolean found_child = FALSE;
+
+ g_return_if_fail (EEL_IS_WRAP_TABLE (wrap_table));
+ g_return_if_fail (g_list_length (wrap_table->details->children) > 0);
+
+ if (position == -1)
+ {
+ position = g_list_length (wrap_table->details->children) - 1;
+ }
+
+ g_return_if_fail (position >= 0);
+ g_return_if_fail ((guint) position < g_list_length (wrap_table->details->children));
+
+ for (node = wrap_table->details->children; node != NULL; node = node->next)
+ {
+ GtkWidget *next_child;
+ next_child = node->data;
+
+ if (next_child == child)
+ {
+ g_assert (found_child == FALSE);
+ found_child = TRUE;
+ }
+ }
+
+ g_return_if_fail (found_child);
+
+ wrap_table->details->children = g_list_remove (wrap_table->details->children, child);
+ wrap_table->details->children = g_list_insert (wrap_table->details->children, child, position);
+
+ gtk_widget_queue_resize (GTK_WIDGET (wrap_table));
+}
+
+/**
+ * eel_wrap_table_get_num_children:
+ * @wrap_table: A EelWrapTable.
+ *
+ * Returns: The number of children being managed by the wrap table.
+ */
+guint
+eel_wrap_table_get_num_children (const EelWrapTable *wrap_table)
+{
+ g_return_val_if_fail (EEL_IS_WRAP_TABLE (wrap_table), 0);
+
+ return g_list_length (wrap_table->details->children);
+}
+
+GtkWidget *
+eel_scrolled_wrap_table_new (gboolean homogenous,
+ GtkShadowType shadow_type,
+ GtkWidget **wrap_table_out)
+{
+ GtkWidget *scrolled_window;
+ GtkWidget *wrap_table;
+ GtkWidget *viewport;
+
+ g_return_val_if_fail (wrap_table_out != NULL, NULL);
+
+ scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
+ GTK_POLICY_NEVER,
+ GTK_POLICY_AUTOMATIC);
+
+ viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)),
+ gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
+ gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport),
+ shadow_type);
+
+ gtk_container_add (GTK_CONTAINER (scrolled_window),
+ viewport);
+
+ wrap_table = eel_wrap_table_new (homogenous);
+ gtk_container_add (GTK_CONTAINER (viewport),
+ wrap_table);
+
+ gtk_widget_show (wrap_table);
+ gtk_widget_show (viewport);
+
+ EEL_WRAP_TABLE (wrap_table)->details->is_scrolled = 1;
+
+ *wrap_table_out = wrap_table;
+ return scrolled_window;
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-07-26 07:13:41 +0000